Wie kann man auf Variablen zugreifen, die in einer Funktion in einer anderen Funktion definiert und definiert sind?

Question

Kann mir jemand sagen, wie man auf Variablen zugreifen kann, die in einer Funktion in einer anderen Funktion deklariert und definiert sind. ZB

void function1() 
{ 
    string abc; 
} 

void function2() 
{ 
    I want to access abc here. 
} 

Wie geht das? Ich weiß, dass wir Parameter verwenden können, aber gibt es einen anderen Weg?

Answer 1

Die C++ Art und Weise ist abc unter Bezugnahme auf Ihre Funktion zu übergeben:

void function1() 
{ 
    std::string abc; 
    function2(abc); 
} 
void function2(std::string &passed) 
{ 
    passed = "new string"; 
} 

Sie auch Ihre Zeichenfolge als Zeiger und dereferenzieren in function2 passieren kann. Dies ist mehr der C-Stil Art und Weise, Dinge zu tun und ist nicht so sicher (zB ein NULL-Zeiger in weitergegeben werden kann, und ohne gute Fehlerprüfung wird es nicht definiertes Verhalten oder Abstürze führen.

void function1() 
{ 
    std::string abc; 
    function2(&abc); 
} 
void function2(std::string *passed) 
{ 
    *passed = "new string"; 
} 

Answer 2

Es gibt absolut keinen Weg. Auf die Variablen des Blocks kann NUR von diesem Block aus zugegriffen werden.

Zeiger/Referenzen auf das Objekt können in Funktionen übergeben werden, die von diesem Block als Parameter aufgerufen werden.

Answer 3

es global Make dann beide können es manipulieren

string abc; 

void function1(){ 
    abc = "blah"; 
} 

void function2(){ 
    abc = "hello"; 
} 

Answer 4

Wenn Sie eine Variable in function1 haben, die Sie in function2 verwenden möchten, dann müssen Sie entweder:.

1. Pass direkt,
2. haben eine höhere Scope-Funktion, die sowohl deklarieren die Variable aufruft und übergeben Sie es, oder
3. es eine globale erklären und dann können alle Funktionen zugreifen es

Wenn Ihr function2 von function1 aufgerufen wird, dann können Sie übergeben Sie es einfach als Argument für function2.

void function1() 
{ 
    std::string abc; 
    function2(abc); 
} 

void function2(std::string &passed) 
{ 
    // function1::abc is now aliased as passed and available for general usage. 
    cout << passed << " is from function1."; 
} 

Wenn function1 nicht function2 nicht nennen, aber beide von function3 genannt werden, dann deklarieren function3 die Variable und übergeben es an beiden function1 und function2 als Argument.

void parentFunction() 
{ 
    std::string abc; 
    function1(abc); 
    function2(abc); 
} 
void function1(std::string &passed) 
{ 
    // Parent function's variable abc is now aliased as passed and available for general usage. 
    cout << passed << " is from parent function."; 
} 
void function2(std::string &passed) 
{ 
    // Parent function's variable abc is now aliased as passed and available for general usage. 
    cout << passed << " is from parent function."; 
}  

Schließlich, wenn weder function1 noch function2 voneinander genannt wird, noch von der gleichen Funktion in Code, erklären dann die Variable als global geteilt werden, und function1 und function2 werden in der Lage sein, direkt zu nutzen .

std::string global_abc; 
void function1() 
{ 
    cout << global_abc << " is available everywhere."; 
} 
void function2() 
{ 
    cout << global_abc << " is available everywhere."; 
}