Différence entre variable statique, auto, globale et locale dans le contexte de c et c ++
Je suis un peu confus au sujet des variables static, auto, global et local.
Quelque part, j’ai lu qu’une variable static n’était accessible que dans la fonction, mais qu’elles existaient toujours (restaient dans la mémoire) après le retour de la fonction.
Cependant, je sais aussi qu'une variable local fait la même chose, alors quelle est la différence?
Il y a deux concepts distincts ici:
- scope, qui détermine où accéder à un nom, et
- durée de stockage, qui détermine le moment où une variable est créée et détruite.
Local les variables (sur le plan pakistanais, les variables avec block scope) ne sont accessibles que dans le bloc de code dans lequel elles sont déclarées:
void f() {
int i;
i = 1; // OK: in scope
}
void g() {
i = 2; // Error: not in scope
}
Global variables (sur le plan pédagogique, les variables avec portée du fichier (en C) ou portée de l'espace de noms (en C++)) sont accessibles à tout moment après leur déclaration. :
int i;
void f() {
i = 1; // OK: in scope
}
void g() {
i = 2; // OK: still in scope
}
(En C++, la situation est plus compliquée puisque les espaces de noms peuvent être fermés et rouverts et que des étendues autres que celle actuellement utilisée sont accessibles et que les noms peuvent également avoir une portée de classe. Mais cela devient très sujet.)
Automatique les variables (sur le plan pédagogique, les variables avec durée de stockage automatique) sont des variables locales dont la durée de vie se termine lorsque l'exécution quitte leur portée et qui sont recréées lorsque la portée est rentrée.
for (int i = 0; i < 5; ++i) {
int n = 0;
printf("%d ", ++n); // prints 1 1 1 1 1 - the previous value is lost
}
Les variables statiques (sur le plan pédagogique, les variables avec durée de stockage statique) ont une durée de vie qui dure jusqu'à la fin du programme. S'il s'agit de variables locales, leur valeur persiste lorsque l'exécution quitte leur portée.
for (int i = 0; i < 5; ++i) {
static int n = 0;
printf("%d ", ++n); // prints 1 2 3 4 5 - the value persists
}
Notez que le mot clé static a différentes significations en dehors de la durée de stockage statique. Sur une variable globale ou une fonction, cela donne lien interne afin qu’elle ne soit pas accessible à partir d’autres unités de traduction; sur un membre de la classe C++, cela signifie qu'il y a une instance par classe plutôt qu'une par objet. De plus, en C++, le mot clé auto ne signifie plus la durée de stockage automatique; cela signifie maintenant un type automatique, déduit de l'initialiseur de la variable.
Tout d'abord je dis que vous devriez google ceci comme il est défini en détail dans beaucoup d'endroits
Local
Ces variables n'existent que dans la fonction spécifique qui les crée. Ils sont inconnus des autres fonctions et du programme principal. En tant que tels, ils sont normalement implémentés en utilisant une pile. Les variables locales cessent d'exister une fois que la fonction qui les a créées est terminée. Ils sont recréés à chaque fois qu'une fonction est exécutée ou appelée.
Global
Ces variables peuvent être consultées (c'est-à-dire connues) par n'importe quelle fonction du programme. Ils sont implémentés en associant des emplacements de mémoire à des noms de variables. Ils ne sont pas recréés si la fonction est rappelée.
/* Demonstrating Global variables */
#include <stdio.h>
int add_numbers( void ); /* ANSI function prototype */
/* These are global variables and can be accessed by functions from this point on */
int value1, value2, value3;
int add_numbers( void )
{
auto int result;
result = value1 + value2 + value3;
return result;
}
main()
{
auto int result;
value1 = 10;
value2 = 20;
value3 = 30;
result = add_numbers();
printf("The sum of %d + %d + %d is %d\n",
value1, value2, value3, final_result);
}
Sample Program Output
The sum of 10 + 20 + 30 is 60
La portée des variables globales peut être restreinte en plaçant soigneusement la déclaration. Ils sont visibles depuis la déclaration jusqu'à la fin du fichier source actuel.
#include <stdio.h>
void no_access( void ); /* ANSI function prototype */
void all_access( void );
static int n2; /* n2 is known from this point onwards */
void no_access( void )
{
n1 = 10; /* illegal, n1 not yet known */
n2 = 5; /* valid */
}
static int n1; /* n1 is known from this point onwards */
void all_access( void )
{
n1 = 10; /* valid */
n2 = 3; /* valid */
}
Statique:
L'objet statique est un objet qui persiste depuis sa construction jusqu'à la fin du programme. Ainsi, les objets pile et tas sont exclus. Mais les objets globaux, les objets situés dans la portée de l'espace de noms, les objets déclarés statiques dans des classes/fonctions et les objets déclarés dans la portée du fichier sont inclus dans les objets statiques. Les objets statiques sont détruits lorsque le programme cesse de fonctionner.
Je vous suggère de voir la liste de ce tutoriel
AUTO:
C, C++
(Appelées variables automatiques.)
Toutes les variables déclarées dans un bloc de code sont automatiques par défaut, mais cela peut être explicité à l'aide du mot clé auto. [Note 1] Une variable automatique non initialisée a une valeur indéfinie jusqu'à ce qu'une valeur valide de son type lui soit affectée. [1]
Utiliser le registre de classe de stockage au lieu de auto est un indice pour le compilateur de mettre en cache la variable dans un registre de processeur. Hormis le fait de ne pas autoriser l’opérateur de référencement (&) à être utilisé sur la variable ou l’un de ses sous-composants, le compilateur est libre d’ignorer le conseil.
En C++, le constructeur de variables automatiques est appelé lorsque l'exécution atteint le lieu de la déclaration. Le destructeur est appelé lorsqu'il atteint la fin du bloc de programme donné (les blocs de programme sont entourés d'accolades). Cette fonctionnalité est souvent utilisée pour gérer l’allocation de ressources et la désallocation, comme ouvrir puis fermer automatiquement des fichiers ou libérer de la mémoire . VOIR WIKIPEDIA
La différence est que les variables statiques sont ces variables: ce qui permet de conserver une valeur d'un appel de la fonction à un autre. Mais dans le cas de variables locales, la portée est jusqu'à la durée de vie du bloc/de la fonction.
Par exemple:
#include <stdio.h>
void func() {
static int x = 0; // x is initialized only once across three calls of func()
printf("%d\n", x); // outputs the value of x
x = x + 1;
}
int main(int argc, char * const argv[]) {
func(); // prints 0
func(); // prints 1
func(); // prints 2
return 0;
}
static est un mot fortement surchargé en C et C++. static les variables dans le contexte d'une fonction sont des variables qui conservent leurs valeurs entre les appels. Ils existent pour la durée du programme.
les variables locales ne persistent que pendant la durée de vie d'une fonction ou quelle que soit leur portée. Par exemple:
void foo()
{
int i, j, k;
//initialize, do stuff
} //i, j, k fall out of scope, no longer exist
Parfois, cette portée est utilisée exprès avec { } blocs:
{
int i, j, k;
//...
} //i, j, k now out of scope
des variables globales existent pour la durée du programme.
auto est maintenant différent en C et C++. auto en C était un moyen (superflu) de spécifier une variable locale. En C++ 11, auto est maintenant utilisé pour dériver automatiquement le type d'une valeur/expression.
Les variables locales sont non existantes dans la mémoire après la fin de la fonction.
Cependant static variables restent allouées en mémoire pendant toute la durée du programme, quelle que soit sa fonction.
De plus, à partir de votre question, les variables static peuvent être déclarées localement dans class ou dans l'étendue de la fonction et globalement dans namespace ou dans l'étendue du fichier. La mémoire leur est allouée du début à la fin, il s’agit simplement de l’initialisation qui se produit tôt ou tard.
Lorsqu'une variable est déclarée statique dans une classe, elle devient une variable partagée pour tous les objets de cette classe, ce qui signifie que la variable est plus spécifique à un objet. Par exemple: -
#include<iostream.h>
#include<conio.h>
class test
{
void fun()
{
static int a=0;
a++;
cout<<"Value of a = "<<a<<"\n";
}
};
void main()
{
clrscr();
test obj1;
test obj2;
test obj3;
obj1.fun();
obj2.fun();
obj3.fun();
getch();
}
Ce programme générera la sortie suivante: -
Value of a = 1
Value of a = 2
Value of a = 3
Il en va de même pour la variable statique déclarée globalement. Le code ci-dessus générera le même résultat si nous déclarons la variable comme une fonction extérieure void fun ()
Alors que si vous supprimez le mot clé static et déclarez une variable locale/globale non statique, la sortie sera comme suit: -
Value of a = 1
Value of a = 1
Value of a = 1