Les variables globales sont-elles mauvaises? [fermé]

En C / C ++, les variables globales sont-elles aussi mauvaises que mon professeur le pense?

Le problème avec les variables globales est que, puisque chaque fonction y a accès, il devient de plus en plus difficile de déterminer quelles fonctions lisent et écrivent réellement ces variables.

Pour comprendre comment fonctionne l'application, vous devez à peu près tenir compte de chaque fonction qui modifie l'état global. Cela peut être fait, mais à mesure que l'application se développe, cela deviendra plus difficile au point d'être pratiquement impossible (ou du moins une perte de temps complète).

Si vous ne comptez pas sur des variables globales, vous pouvez passer l'état entre différentes fonctions selon vos besoins. De cette façon, vous avez de bien meilleures chances de comprendre ce que fait chaque fonction, car vous n'avez pas besoin de prendre en compte l'état global.

L'important est de se souvenir de l'objectif global: la clarté

La règle «pas de variables globales» existe parce que la plupart du temps, les variables globales rendent la signification du code moins claire.

Cependant, comme beaucoup de règles, les gens se souviennent de la règle, et non de ce que la règle était censée faire.

J'ai vu des programmes qui semblent doubler la taille du code en passant un nombre énorme de paramètres pour éviter simplement le mal des variables globales. En fin de compte, l'utilisation de globaux aurait rendu le programme plus clair pour ceux qui le liraient . En adhérant inconsidérément au mot de la règle, le programmeur d'origine avait échoué à l'intention de la règle.

Donc, oui, les globaux sont souvent mauvais. Mais si vous pensez qu'en fin de compte, l'intention du programmeur est rendue plus claire par l'utilisation de variables globales, alors allez-y. Cependant, rappelez-vous la baisse de clarté qui s'ensuit automatiquement lorsque vous forcez quelqu'un à accéder à un deuxième morceau de code (les globaux) pour comprendre comment fonctionne le premier morceau.

Mon professeur avait l'habitude de dire quelque chose comme: utiliser des variables globales est correct si vous les utilisez correctement. Je ne pense pas que je sois jamais arrivé à les utiliser correctement, donc je les ai rarement utilisés du tout.

Les variables globales ne doivent être utilisées que si vous n'avez pas d'autre alternative. Et oui, cela inclut les singletons. Dans 90% des cas, des variables globales sont introduites pour réduire le coût de contournement d'un paramètre. Et puis le codage multithreading / test unitaire / maintenance se produit, et vous avez un problème.

Alors oui, dans 90% des situations, les variables globales sont mauvaises. Les exceptions ne sont pas susceptibles d'être vues par vous pendant vos années de collège. Une exception à laquelle je peux penser du haut de ma tête concerne les objets intrinsèquement globaux tels que les tables d'interruption. Des choses comme la connexion DB semblent être mondiales, mais ce n'est pas le cas.

Le problème que les variables globales créent pour le programmeur est qu'il étend la surface de couplage inter-composants entre les différents composants qui utilisent les variables globales. Cela signifie que lorsque le nombre de composants utilisant une variable globale augmente, la complexité des interactions peut également augmenter. Ce couplage accru rend généralement les défauts plus faciles à injecter dans le système lors des modifications et rend également les défauts plus difficiles à diagnostiquer et à corriger. Ce couplage accru peut également réduire le nombre d'options disponibles lors des modifications et il peut augmenter l'effort requis pour les modifications, car il faut souvent suivre les différents modules qui utilisent également la variable globale afin de déterminer les conséquences des changements.

Le but de l' encapsulation , qui est fondamentalement le contraire de l'utilisation de variables globales, est de diminuer le couplage afin de rendre la compréhension et le changement de source plus faciles et plus sûrs et plus facilement testés. Il est beaucoup plus facile d'utiliser les tests unitaires lorsque les variables globales ne sont pas utilisées.

Par exemple, si vous avez une simple variable entière globale qui est utilisée comme indicateur énuméré que divers composants utilisent comme machine d'état et que vous apportez ensuite une modification en ajoutant un nouvel état pour un nouveau composant, vous devez ensuite suivre tous les autres composants pour garantir que le changement ne les affectera pas. Un exemple d'un problème possible serait si une switchinstruction pour tester la valeur de la variable globale d'énumération avec des caseinstructions pour chacune des valeurs actuelles est utilisée à divers endroits et il se trouve que certaines switchinstructions n'ont pas de defaultcas à gérer une valeur inattendue pour le global tout d'un coup vous avez un comportement indéfini en ce qui concerne l'application.

D'un autre côté, l'utilisation d'une zone de données partagée peut être utilisée pour contenir un ensemble de paramètres globaux référencés dans toute l'application. Cette approche est souvent utilisée avec des applications intégrées avec de petites empreintes mémoire.

Lorsque vous utilisez des variables globales dans ce type d'applications, la responsabilité de l'écriture dans la zone de données est généralement attribuée à un seul composant et tous les autres composants voient la zone comme constet y lisent, sans jamais y écrire. Cette approche limite les problèmes qui peuvent se développer.

Quelques problèmes de variables globales qui doivent être contournés

Lorsque la source d'une variable globale telle qu'une structure est modifiée, tout ce qui l'utilise doit être recompilé afin que tout ce qui utilise la variable connaisse sa taille réelle et son modèle de mémoire.

Si plusieurs composants peuvent modifier la variable globale, vous pouvez rencontrer des problèmes avec des données incohérentes dans la variable globale. Avec une application multithread, vous devrez probablement ajouter une sorte de verrouillage ou une région critique pour fournir un moyen de sorte qu'un seul thread à la fois puisse modifier la variable globale et lorsqu'un thread modifie la variable, toutes les modifications sont terminées et validée avant que d'autres threads puissent interroger la variable ou la modifier.

Le débogage d'une application multithread qui utilise une variable globale peut être plus difficile. Vous pouvez rencontrer des conditions de concurrence qui peuvent créer des défauts difficiles à reproduire. Étant donné que plusieurs composants communiquent via une variable globale, en particulier dans une application multithread, il est très difficile de comprendre quel composant modifie la variable quand et comment il modifie la variable.

Le conflit de noms peut être un problème avec l'utilisation de variables globales. Une variable locale qui porte le même nom qu'une variable globale peut masquer la variable globale. Vous rencontrez également le problème de convention de dénomination lors de l'utilisation du langage de programmation C. Une solution consiste à diviser le système en sous-systèmes avec les variables globales pour un sous-système particulier commençant toutes par les mêmes trois premières lettres (voir ceci sur la résolution des collisions d'espace de nom dans l'objectif C ). C ++ fournit des espaces de noms et avec C, vous pouvez contourner cela en créant une structure globalement visible dont les membres sont divers éléments de données et pointeurs vers des données et des fonctions qui sont fournies dans un fichier comme statique, donc avec une visibilité de fichier uniquement afin qu'elles ne puissent être référencées qu'à travers la structure globalement visible.

Dans certains cas, l'intention de l'application d'origine est modifiée de sorte que les variables globales qui ont fourni l'état d'un seul thread sont modifiées pour permettre l'exécution de plusieurs threads en double. Un exemple serait une application simple conçue pour un seul utilisateur utilisant des variables globales pour l'état, puis une demande provient de la direction pour ajouter une interface REST pour permettre aux applications distantes d'agir en tant qu'utilisateurs virtuels. Alors maintenant, vous devez dupliquer les variables globales et leurs informations d'état afin que l'utilisateur unique ainsi que chacun des utilisateurs virtuels des applications distantes aient leur propre ensemble unique de variables globales.

Utiliser C ++ namespaceet la structtechnique pour C

Pour le langage de programmation C ++, la namespacedirective aide énormément à réduire les risques de conflit de noms. namespaceainsi que classet les différents mots - clés d'accès ( private, protectedet public) fournir la plupart des outils dont vous avez besoin pour les variables encapsulent. Cependant, le langage de programmation C ne fournit pas cette directive. Cette publication stackoverflow, Namespaces in C , fournit quelques techniques pour C.

Une technique utile consiste à avoir une seule zone de données résidentes en mémoire qui est définie comme structayant une visibilité globale et dans laquelle se structtrouvent des pointeurs vers les différentes variables et fonctions globales qui sont exposées. Les définitions réelles des variables globales se voient attribuer une portée de fichier à l'aide du staticmot - clé. Si vous utilisez ensuite le constmot clé pour indiquer celles qui sont en lecture seule, le compilateur peut vous aider à appliquer l'accès en lecture seule.

L'utilisation de la structtechnique peut également encapsuler le global afin qu'il devienne une sorte de package ou de composant qui se trouve être un global. En ayant un composant de ce type, il devient plus facile de gérer les changements qui affectent le global et les fonctionnalités utilisant le global.

Cependant, même si namespacela structtechnique peut aider à gérer les conflits de noms, les problèmes sous-jacents de couplage inter-composants que l'utilisation de globaux introduit en particulier dans une application multi-thread moderne, existent toujours.

Oui, mais vous n'encourez pas le coût des variables globales jusqu'à ce que vous cessez de travailler dans le code qui utilise des variables globales et commencez à écrire quelque chose d'autre qui utilise le code qui utilise des variables globales. Mais le coût est toujours là.

En d'autres termes, c'est un coût indirect à long terme et en tant que tel, la plupart des gens pensent que ce n'est pas mauvais.

S'il est possible que votre code soit soumis à un examen approfondi lors d'un procès devant la Cour suprême , vous devez vous assurer d'éviter les variables globales.

Voir cet article: Le code de l'alcootest buggy reflète l'importance de l'examen des sources

Il y avait quelques problèmes avec le style du code qui ont été identifiés par les deux études. L'un des problèmes stylistiques qui préoccupaient les examinateurs était l'utilisation extensive de variables globales non protégées . Ceci est considéré comme une forme médiocre car cela augmente le risque que l'état du programme devienne incohérent ou que les valeurs soient modifiées ou écrasées par inadvertance. Les chercheurs ont également exprimé leur inquiétude quant au fait que la précision décimale n'est pas maintenue de manière cohérente dans tout le code.

Mec, je parie que ces développeurs souhaitent qu'ils n'aient pas utilisé de variables globales!

Les variables globales sont aussi mauvaises que vous les créez, pas moins.

Si vous créez un programme entièrement encapsulé, vous pouvez utiliser des globaux. C'est un «péché» d'utiliser les globaux, mais les péchés de programmation sont assez philosophiques.

Si vous consultez L.in.oleum , vous verrez un langage dont les variables sont uniquement globales. C'est non évolutif parce que les bibliothèques n'ont pas d'autre choix que d'utiliser des globaux.

Cela dit, si vous avez des choix et pouvez ignorer la philosophie du programmeur, les globaux ne sont pas si mauvais.

Gotos non plus, si vous les utilisez correctement.

Le gros "mauvais" problème est que, si vous les utilisez mal, les gens hurlent, le mars lander plante et le monde explose ... ou quelque chose comme ça.

Je répondrais à cette question par une autre question: utilisez-vous des singeltons / les singeltons sont-ils mauvais?

Parce que (presque tous) l'utilisation de singelton est une variable globale glorifiée.

Le problème est moins qu'ils sont mauvais et plus qu'ils sont dangereux . Ils ont leur propre ensemble d'avantages et d'inconvénients, et il y a des situations où ils sont soit le moyen le plus efficace soit le seul moyen d'accomplir une tâche particulière. Cependant, ils sont très faciles à mal utiliser, même si vous prenez des mesures pour toujours les utiliser correctement.

Quelques avantages:

• Accessible depuis n'importe quelle fonction.
• Accessible à partir de plusieurs threads.
• Ne sortira jamais de la portée jusqu'à la fin du programme.

Quelques inconvénients:

• Accessible à partir de n'importe quelle fonction, sans avoir besoin d'être explicitement glissé en tant que paramètre et / ou documenté.
• Pas thread-safe.
• Pollue l'espace de noms global et peut potentiellement provoquer des collisions de noms, sauf si des mesures sont prises pour éviter cela.

Notez, si vous voulez, que les deux premiers avantages et les deux premiers inconvénients que j'ai énumérés sont exactement la même chose, juste avec un libellé différent. En effet, les fonctionnalités d'une variable globale peuvent en effet être utiles, mais les fonctionnalités mêmes qui les rendent utiles sont à l'origine de tous leurs problèmes.

Quelques solutions potentielles à certains des problèmes:

• Demandez-vous s'il s'agit en fait de la solution la meilleure ou la plus efficace au problème. S'il existe de meilleures solutions, utilisez-les à la place.
• Placez-les dans un espace de noms [C ++] ou une structure singleton [C, C ++] avec un nom unique (un bon exemple serait Globalsou GlobalVars), ou utilisez une convention de dénomination standardisée pour les variables globales (comme global_[name]ou g_module_varNameStyle(comme mentionné par underscore_d dans les commentaires) )). Cela documentera à la fois leur utilisation (vous pouvez trouver du code qui utilise des variables globales en recherchant le nom d'espace / nom de structure) et minimiser l'impact sur l'espace de nom global.
• Pour toute fonction qui accède aux variables globales, documentez explicitement les variables qu'elle lit et qu'elle écrit. Cela facilitera le dépannage.
• Placez-les dans leur propre fichier source et déclarez-les externdans l'en-tête associé, afin que leur utilisation puisse être limitée aux unités de compilation qui doivent y accéder. Si votre code repose sur un grand nombre de variables globales, mais que chaque unité de compilation n'a besoin d'accéder qu'à une poignée d'entre elles, vous pouvez envisager de les trier dans plusieurs fichiers source, il est donc plus facile de limiter l'accès de chaque fichier aux variables globales.
• Configurez un mécanisme pour les verrouiller et les déverrouiller, et / ou concevez votre code de sorte que le moins de fonctions possible aient réellement besoin de modifier les variables globales. Les lire est beaucoup plus sûr que de les écrire, bien que les races de threads puissent toujours causer des problèmes dans les programmes multithreads.
• Fondamentalement, minimisez l'accès à ces derniers et maximisez l'unicité du nom. Vous voulez éviter les collisions de noms et avoir le moins de fonctions possible qui peuvent potentiellement modifier une variable donnée.

Qu'ils soient bons ou mauvais dépend de la façon dont vous les utilisez. La majorité a tendance à les mal utiliser, d'où la méfiance générale à leur égard. S'ils sont utilisés correctement, ils peuvent être une aubaine majeure; si elle est utilisée mal, cependant, ils peuvent et vont revenir à vous mordre quand et comment vous attendez le moins.

Une bonne façon de voir les choses est qu’elles-mêmes ne sont pas mauvaises, mais elles permettent une mauvaise conception et peuvent multiplier de manière exponentielle les effets d’une mauvaise conception.

Même si vous n'avez pas l'intention de les utiliser, il vaut mieux savoir comment les utiliser en toute sécurité et choisir de ne pas les utiliser, que de ne pas les utiliser parce que vous ne savez pas comment les utiliser en toute sécurité. Si jamais vous vous trouvez dans une situation où vous devez conserver du code préexistant qui repose sur des variables globales, vous pourriez avoir des difficultés si vous ne savez pas comment les utiliser correctement.

Comme quelqu'un l'a dit (je paraphrase) dans un autre fil de discussion "Des règles comme celle-ci ne devraient pas être enfreintes, jusqu'à ce que vous compreniez pleinement les conséquences de le faire."

Il y a des moments où des variables globales sont nécessaires, ou du moins très utiles (travailler avec des rappels définis par le système par exemple). D'un autre côté, ils sont également très dangereux pour toutes les raisons qui vous ont été dites.

Il existe de nombreux aspects de la programmation qui devraient probablement être laissés aux experts. Parfois, vous avez besoin d'un couteau très tranchant. Mais vous ne pouvez pas en utiliser un avant d'être prêt ...

Les variables globales sont généralement mauvaises, surtout si d'autres personnes travaillent sur le même code et ne veulent pas passer 20 minutes à rechercher tous les endroits auxquels la variable est référencée. Et l'ajout de threads qui modifient les variables apporte un tout nouveau niveau de maux de tête.

Les constantes globales dans un espace de noms anonyme utilisé dans une seule unité de traduction sont fines et omniprésentes dans les applications et bibliothèques professionnelles. Mais si les données sont modifiables et / ou doivent être partagées entre plusieurs UT, vous voudrez peut-être les encapsuler - si ce n'est pour des raisons de conception, alors pour le débogage de quiconque ou pour travailler avec votre code.

L'utilisation de variables globales est un peu comme balayer la saleté sous un tapis. C'est une solution rapide et beaucoup plus facile à court terme que de se débarrasser d'un aspirateur ou d'un aspirateur pour le nettoyer. Cependant, si vous finissez par déplacer le tapis plus tard, vous aurez un gros désordre surprise en dessous.

Les variables globales sont mauvaises, si elles vous permettent de manipuler des aspects d'un programme qui ne doivent être modifiés que localement. Dans la POO, les globaux entrent souvent en conflit avec l'idée d'encapsulation.

Je pense que votre professeur essaie d'arrêter une mauvaise habitude avant même qu'elle ne commence.

Les variables globales ont leur place et comme beaucoup de gens l'ont dit, savoir où et quand les utiliser peut être compliqué. Je pense donc que plutôt que d'entrer dans le vif du sujet, pourquoi, comment, quand et où des variables globales votre professeur a décidé de simplement interdire. Qui sait, il pourrait les interdire à l'avenir.

Absolument pas. Les abuser cependant ... c'est mauvais.

Les supprimer sans raison pour le plaisir est juste que ... sans raison. À moins que vous ne connaissiez les avantages et les inconvénients, il est préférable de rester clair et de faire ce que vous avez appris / appris, mais il n'y a rien de mal implicitement avec les variables globales. Lorsque vous comprenez les avantages et les inconvénients, prenez votre propre décision.

Les variables globales sont bien dans les petits programmes, mais horribles si elles sont utilisées de la même manière dans les grands.

Cela signifie que vous pouvez facilement prendre l'habitude de les utiliser tout en apprenant. C'est de cela que votre professeur essaie de vous protéger.

Lorsque vous êtes plus expérimenté, il sera plus facile d'apprendre quand ils vont bien.

Non, ce n'est pas mal du tout. Vous devez regarder le code (machine) produit par le compilateur pour faire cette détermination, parfois il est bien pire d'utiliser un local qu'un global. Notez également que mettre "statique" sur une variable locale en fait fondamentalement une variable globale (et crée d'autres problèmes laids qu'un véritable global résoudrait). les "globaux locaux" sont particulièrement mauvais.

Les globaux vous donnent également un contrôle net sur votre utilisation de la mémoire, ce qui est beaucoup plus difficile à faire avec les locaux. De nos jours, cela n'a d'importance que dans les environnements embarqués où la mémoire est assez limitée. Quelque chose à savoir avant de supposer que l'embarqué est le même que les autres environnements et que les règles de programmation sont les mêmes à tous les niveaux.

Il est bon que vous remettiez en question les règles enseignées, la plupart d'entre elles ne le sont pas pour les raisons qui vous sont données. La leçon la plus importante n'est cependant pas que c'est une règle à transporter avec vous pour toujours, mais c'est une règle requise pour honorer afin de passer cette classe et aller de l'avant. Dans la vie, vous constaterez que pour la société XYZ, vous aurez d'autres règles de programmation que vous devrez finalement respecter afin de continuer à recevoir un chèque de paie. Dans les deux situations, vous pouvez contester la règle, mais je pense que vous aurez beaucoup plus de chance au travail qu'à l'école. Vous n'êtes qu'un autre parmi de nombreux étudiants, votre siège sera bientôt remplacé, les professeurs ne le feront pas, à un poste, vous faites partie d'une petite équipe de joueurs qui doivent voir ce produit jusqu'au bout et dans cet environnement, les règles développées sont pour le au bénéfice des membres de l'équipe ainsi que du produit et de l'entreprise, donc si tout le monde est du même avis ou si pour le produit particulier il y a une bonne raison d'ingénierie pour violer quelque chose que vous avez appris au collège ou un livre sur la programmation générique, alors vendez votre idée à l'équipe et écrivez-la comme une méthode valide sinon la méthode préférée . Tout est un jeu équitable dans le monde réel.

Si vous suivez toutes les règles de programmation qui vous sont enseignées à l'école ou dans les livres, votre carrière en programmation sera extrêmement limitée. Vous pouvez probablement survivre et mener une carrière fructueuse, mais l'étendue et la largeur des environnements à votre disposition seront extrêmement limitées. Si vous savez comment et pourquoi la règle est là et que vous pouvez la défendre, c'est bien, si votre seule raison est "parce que mon professeur l'a dit", eh bien ce n'est pas si bon.

Notez que des sujets comme celui-ci sont souvent débattus sur le lieu de travail et continueront de l'être, à mesure que les compilateurs et les processeurs (et les langues) évoluent, ce genre de règles évolue et sans défendre votre position et peut-être une leçon donnée par quelqu'un avec une autre opinion que vous ne connaissez pas Avance.

En attendant, faites tout ce que dit celui qui parle le plus fort ou qui porte le plus gros bâton (jusqu'à ce que vous soyez celui qui crie le plus fort et porte le plus gros bâton).

Je voudrais argumenter contre le fait que tout au long de ce fil de discussion soit dit qu'il rend le multi-filetage plus difficile ou impossible en soi. Les variables globales sont un état partagé, mais les alternatives aux globales (par exemple en passant des pointeurs) peuvent également partager l'état. Le problème avec le multithread est de savoir comment utiliser correctement l'état partagé, pas si cet état se trouve être partagé via une variable globale ou autre chose.

La plupart du temps, lorsque vous faites du multi-threading, vous devez partager quelque chose. Dans un modèle producteur-consommateur par exemple, vous pouvez partager une file d'attente thread-safe qui contient les unités de travail. Et vous êtes autorisé à le partager car cette structure de données est thread-safe. Que cette file d'attente soit globale ou non est totalement hors de propos en ce qui concerne la sécurité des threads.

L'espoir implicite exprimé tout au long de ce fil de discussion que la transformation d'un programme d'un fil unique à plusieurs fils sera plus facile lorsque vous n'utilisez pas de globaux est naïf. Oui, les globaux facilitent la prise de vue dans le pied, mais il existe de nombreuses façons de se tirer une balle.

Je ne préconise pas les globaux, car les autres points restent valables, mon point est simplement que le nombre de threads dans un programme n'a rien à voir avec une portée variable.

Oui, car si vous laissez les programmeurs incompétents les utiliser (lire 90% en particulier les scientifiques), vous vous retrouvez avec plus de 600 variables globales réparties sur plus de 20 fichiers et un projet de 12 000 lignes où 80% des fonctions annulent, renvoient et fonctionnent entièrement sur l'état mondial.

Il devient rapidement impossible de comprendre ce qui se passe à un moment donné à moins que vous ne connaissiez l'ensemble du projet.

L'utilisation de variables globales dépend en fait des exigences. Son avantage est que cela réduit la surcharge de transmission répétée des valeurs.

Mais votre professeur a raison car cela pose des problèmes de sécurité, il faut donc éviter autant que possible l'utilisation de variables globales. Les variables globales créent également des problèmes qui sont parfois difficiles à déboguer .

Par exemple:-

Situations où les valeurs des variables sont modifiées lors de l' exécution . À ce moment, il est difficile d'identifier quelle partie du code le modifie et à quelles conditions.

Global est bon en matière de configuration . Lorsque nous voulons que notre configuration / modifications ait un impact global sur l' ensemble du projet .

Nous pouvons donc modifier une configuration et les modifications sont dirigées vers l' ensemble du projet . Mais je dois vous avertir qu'il faudrait être très intelligent pour utiliser les globaux.

Tôt ou tard, vous devrez changer la façon dont cette variable est définie ou ce qui se passe lors de son accès, ou il vous suffit de rechercher où elle est modifiée.

Il est pratiquement toujours préférable de ne pas avoir de variables globales. Il suffit d'écrire les méthodes d'obtention et de définition du barrage et de vous glander quand vous en avez besoin un jour, une semaine ou un mois plus tard.

J'utilise généralement des globaux pour les valeurs qui sont rarement modifiées comme les singletons ou les pointeurs de fonction en fonctions dans une bibliothèque chargée dynamiquement. L'utilisation de globaux mutables dans les applications multithread a tendance à entraîner des bogues difficiles à suivre, j'essaie donc d'éviter cela en règle générale.

L'utilisation d'un global au lieu de passer un argument est souvent plus rapide mais si vous écrivez une application multithread, ce que vous faites souvent de nos jours, cela ne fonctionne généralement pas très bien (vous pouvez utiliser des threads statiques mais le gain de performances est discutable) .

Dans les applications Web, une entreprise peut être utilisée pour conserver des données spécifiques à la session / fenêtre / thread / utilisateur sur le serveur pour des raisons d'optimisation et pour éviter la perte de travail lorsque la connexion est instable. Comme mentionné, les conditions de course doivent être gérées. Nous utilisons une seule instance d'une classe pour ces informations et elles sont soigneusement gérées.

En fin de compte, votre programme ou application peut toujours fonctionner, mais c'est une question d'être bien rangé et d'avoir une compréhension complète de ce qui se passe. Si vous partagez une valeur variable entre toutes les fonctions, il peut devenir difficile de déterminer quelle fonction modifie la valeur (si la fonction le fait) et rend le débogage un million de fois plus difficile

la sécurité est moindre signifie que n'importe qui peut manipuler les variables si elles sont déclarées globales, pour celle-ci pour expliquer, prenez cet exemple si vous avez le solde comme variable globale dans votre programme bancaire, la fonction utilisateur peut manipuler cela ainsi que l'agent de banque peut également manipuler cela pose donc un problème. Seul l'utilisateur doit se voir attribuer la fonction de lecture seule et de retrait, mais le greffier de la banque peut ajouter le montant lorsque l'utilisateur remet personnellement l'argent comptant au bureau.

Dans une application multithread, utilisez des variables locales à la place des variables globales pour éviter une condition de concurrence.

Une condition de concurrence critique se produit lorsque plusieurs threads accèdent à une ressource partagée, avec au moins un thread ayant un accès en écriture aux données. Ensuite, le résultat du programme n'est pas prévisible et dépend de l'ordre des accès aux données par différents threads.

Plus d'informations à ce sujet ici, https://software.intel.com/en-us/articles/use-intel-parallel-inspector-to-find-race-conditions-in-openmp-based-multithreaded-code