Verwenden Sie globale Variablen oder mehrere Parameter?

Question

wäre es am besten globale Variablen zu verwenden, wie zum Beispiel:

int bumNum; 
int extraNum; 
bool isIt; 

void setup() 
{ 
    std::cin >> bumNum; 
    std::cin >> extraNum; 
    isIt= false; 
} 

void anotherFunc() 
{ 
    //do something with the global variables 
} 

int main() 
{ 
    setup(); 
    anotherFunc(); 
    return 0; 
} 

oder lokalen Variablen wie:

void setup(int& bumNum, int& extraNum, bool& isIt) 
{ 
    std::cin >> bumNum; 
    std::cin >> extraNum; 
    isIt= false; 
} 

void anotherFunc(int& bumNum, int& extraNum, bool& isIt) 
{ 
    //do something with the global variables 
} 

int main() 
{ 
    int bumNum; 
    int extraNum; 
    bool isIt; 
    setup(bumNum, extraNum, isIt); 
    anotherFunc(); 
    return 0; 
} 

Die erste Option weniger tippen auf die andere Option im Vergleich ist. Die Sache ist, dass globale Variablen nicht wirklich als ein Freund betrachtet werden:/Oh, und es gibt mehr Initialisierungen in der zweiten Option.

Answer 1

Mit globalen Variablen führen Sie einen globalen Zustand, der von sich verschiedenen Themen hat:

• Probleme mit Concurrency (wenn Sie Multithreading hinzufügen, müssen Sie diejenigen zu schützen mit irgendeiner Art von Mutex anfangen zu denken),

• es nicht Maßstab,

• im Laufe der Zeit, wie Sie die Anzahl solcher Variablen erhöhen, ist es mehr und mehr verwirrend als für die Verwendung wird, welche Variablen arbeitet,

um nur einige zu nennen.

Um Ihre Frage zu beantworten - verwenden Sie Parameter über den globalen Zustand, wo immer möglich.

Answer 2

Nutzungsstruktur:

struct Foo 
{ 
    int bumNum = 0; 
    int extraNum = 0; 
    bool isIt = false; 
}; 

std::istream& operator >> (std::istream& is, Foo& foo) 
{ 
    std::cin >> foo.bumNum; 
    std::cin >> foo.extraNum; 
    foo.isIt= false; 
    return is; 
} 

void anotherFunc(Foo& foo) 
{ 
    //do something with the global variables 
} 

int main() 
{ 
    Foo foo;  
    std::cin >> foo; 
    anotherFunc(foo); 
}