Bonjour, alors voilà, j'ai fais un petit programme dans lequel j'utilise plusieurs variables globale. J'ai vu quelque part comme quoi il fallait les éviter le plus possible, et à la place utiliser des pointeur, et je voudrais bien savoir si c'est vrai et si oui pourquoi.

Désolé, c'est surement une question bête mais bon, je débute, merci d'avance de répondre.

C'est vrai qu'il faut éviter d'avoir trop de variables globales car un gros programme peut vite devenir confus comme cela, en revanche ce n'est pas des pointeurs qu'il faut utiliser à la place, cela n'a rien à voir, il faut juste préférablement utiliser des variables locales.

Une variable locale est par exemple une variable que tu déclares et définit à l'intérieur d'une fonction, cette variable ne peut-être utilisée qu'a l'intérieur de la fonction, après elle n'existe plus.

Ou autrement tu utilises des struct qui ont leur propres variables.

A noter qu'un pointeur est aussi une variable et un pointeur peut très bien être global aussi, c'est pour cela que ça n'a aucune rapport.

Ah d'accord, en fait le truc c'est que j'ai un peu plus d'une vingtaine de variable globale, et qu'elle sont toutes utilisé/modifié par plusieurs fonction, donc si je les laisse c'est pas vraiment dérangeant, a part pour la lecture donc ?

Le pire c'est d'avoir des variables globales avec des petits noms comme x ou i car il peut y avoir des conflits avec des variables locales par exemple.

Mais généralement un programme bien conçu ne devrait pas contenir beaucoup de variables globales car cela montre que le programme n'est pas très bien organisé et que tout est un peu mélangé.

Pocolo > La desorganisation du code et les possibles conflits de noms, c'est le seul desavantages aux variables globales ? Ou y'a des trucs un peu plus pousse niveau compilation qui font que c'est a eviter ?

La modification d'une variable globale peut avoir des effets de bord, après tout une variable globale a un impact global

il n'y a pas une différence niveau performances, aussi?

enfin, c'est dans les cas d'optimisation vraiment poussée que ça peut avoir un impact visible.

" La desorganisation du code et les possibles conflits de noms, c'est le seul desavantages aux variables globales ? "

En gros oui mais c'est déjà non négligeable. A noter aussi que lorsque l'on définit plusieurs variables globales dans plusieurs fichiers différents leur ordre d'initialisation n'est pas défini (dans un seul fichier elles sont initialisées dans l'ordre où elles apparaissent mais l'on ne sait pas si les variable du fichier x seront initialisées avant celles du fichier y ou vice versa), encore que ça ce n'est pas forcément gênant.

Au passage j'en profite pour signaler que l'on peut régler les problèmes de conflit entre les variables globales et locales grâce a l'opérateur de résolution de portée ( :: ), exemple :

int var = 0; // variable globale

void fonction()
{
int var = 0; // variable locale

var = 2; // assigne 2 à la variable locale
::var = 7; // assigne 7 à la variable globale
}

Si l'on ne met rien à gauche de l'opérateur "::" on fait référence à la portée globale. Mais c'est quand même mieux d'éviter ce genre de conflit.

Oh, j'oubliais que l'on parlait du C, l'opérateur de résolution de portée n'existe pas en C donc ce que j'ai dit n'est valable que pour C++,toutes mes excuses.

Le probleme de porte peut se regler en C par l'utilisation d'une structure. Ainsi on accede a GLOBALE.var par exemple.

Dans un cas extreme de confusion, que fais le compilateur ?

Par exemple:

int x;

void fonction()
{
int x;

x = 5;
}

Quelle variable X sera attribuee ? Est-ce qu'il est possible de definir deux variables de telle maniere ?

Comme dans l'exemple que j'ai donné plus haut, dans ce cas c'est à la variable locale que tu assignes la valeur. La variable globale est "masquée" par la variable locale.

D'accord, donc ca va chercher le label dans le scope le plus proche ?

Oui, enfin le scope dans lequel le programme se trouve à ce moment-là.

Théoriquement les variables globales qui sont utilisées à l'intérieur d'une fonction devraient être passées en paramètres de la fonction si l'on veut être propre. L'inconvénient par contre en C c'est qu'on a vite tendance à avoir des fonctions avec un très grand nombre de paramètres.

"Théoriquement les variables globales qui sont utilisées à l'intérieur d'une fonction devraient être passées en paramètres de la fonction si l'on veut être propre."

Non. Si il s'agit vraiment d'une variable globale alors la passer en parametre est juste redondant. Les variables globales ont beaucoup d'utilite pour tous les concepts dont il n'existe qu'un seul exemplaire dans l'application. (Typiquement les singletons en programmation oriente objet.)

"L'inconvénient par contre en C c'est qu'on a vite tendance à avoir des fonctions avec un très grand nombre de paramètres."

Les fonctions avec beaucoup de parametre sont des tueurs de performances. Si une fonction prends beaucoup de paramtre, il est souvent preferable de passer un pointeur sur un structure qui contient les parametres.

" Les variables globales ont beaucoup d'utilite pour tous les concepts dont il n'existe qu'un seul exemplaire dans l'application. "

Il y a aussi le keyword "static" pour cela non?

"Non. Si il s'agit vraiment d'une variable globale alors la passer en parametre est juste redondant. Les variables globales ont beaucoup d'utilite pour tous les concepts dont il n'existe qu'un seul exemplaire dans l'application."

Perso je préfère encore être redondant et passer systématiquement en paramètre de ma fonction un pointeur sur une structure qui contient mes variables globales plutôt que d'utiliser des variables qui n'ont pas été déclarées à l'intérieur de ma fonction. Sans ça je n'arrive plus à me relire

"Il y a aussi le keyword "static" pour cela non?"

Non, static a un autre sens en C. une variable globale declare static limite son scope au fichier courant. En d'autre terme, il n'est pas exporte dans la table des symboles. static utilise dans une fonction indique que tous les appels de cette fonction partage la meme variable. C'est donc une variable globale mais dont le scope est limite a la fonction courante. Elle n'est donc pas accessible depuis une autre fonction (meme au sein du meme fichier).

"Perso je préfère encore être redondant et passer systématiquement en paramètre de ma fonction un pointeur sur une structure qui contient mes variables globales plutôt que d'utiliser des variables qui n'ont pas été déclarées à l'intérieur de ma fonction. Sans ça je n'arrive plus à me relire "
Et perdre un registre ou forcer un empilement de plus a chaque appel de fonction? Je ne pense pas que tu y sois gagnant en terme de performance. Et c'est pour cela que l'on fait du C en general...