Quelle est la différence entre une variable statique et une variable const?

Quelqu’un peut-il expliquer la différence entre une variable static et une variable const ?

Une valeur constante ne peut pas changer. Une variable statique existe pour une fonction ou une classe plutôt qu’une instance ou un object.

Ces deux concepts ne s’excluent pas mutuellement et peuvent être utilisés ensemble.

La réponse courte:

Un const est une promesse que vous n’essaierez pas de modifier la valeur une fois définie.

Une variable static signifie que la durée de vie de l’object correspond à l’exécution complète du programme et que sa valeur est initialisée une seule fois avant le démarrage du programme. Toutes les statistiques sont initialisées si vous ne leur atsortingbuez pas de valeur explicite. La manière et le moment de l’initialisation statique ne sont pas spécifiés .

C99 a emprunté l’utilisation de const à C ++. D’autre part, le static a été à l’origine de nombreux débats (dans les deux langues) en raison de sa sémantique souvent déroutante.

En outre, avec C ++ 0x jusqu’à C ++ 11, l’utilisation du mot clé static été déconseillée pour la déclaration d’objects dans la scope de l’espace de noms. Cette dépréciation a été supprimée dans C ++ 11 pour diverses raisons (voir ici ).

La réponse plus longue: Plus sur les mots-clés que vous vouliez savoir (dès les normes):

C99

 #include  #pragma STDC FENV_ACCESS ON /* file scope, static storage, internal linkage */ static int i1; // tentative definition, internal linkage extern int i1; // tentative definition, internal linkage int i2; // external linkage, automatic duration (effectively lifetime of program) int *p = (int []){2, 4}; // unnamed array has static storage /* effect on ssortingng literals */ char *s = "/tmp/fileXXXXXX"; // static storage always, may not be modifiable char *p = (char []){"/tmp/fileXXXXXX"}; // static, modifiable const char *cp = (const char []){"/tmp/fileXXXXXX"} // static, non-modifiable void f(int m) { static int vla[ m ]; // err float w[] = { 0.0/0.0 }; // raises an exception /* block scope, static storage, no-linkage */ static float x = 0.0/0.0; // does not raise an exception /* ... */ /* effect on ssortingng literals */ char *s = "/tmp/fileXXXXXX"; // static storage always, may not be modifiable char *p = (char []){"/tmp/fileXXXXXX"}; // automatic storage, modifiable const char *cp = (const char []){"/tmp/fileXXXXXX"} // automatic storage, non-modifiable } inline void bar(void) { const static int x = 42; // ok // Note: Since an inline definition is distinct from the // corresponding external definition and from any other // corresponding inline definitions in other translation // units, all corresponding objects with static storage // duration are also distinct in each of the definitions static int y = -42; // error, inline function definition } // the last declaration also specifies that the argument // corresponding to a in any call to f must be a non-null // pointer to the first of at least three arrays of 5 doubles void f(double a[static 3][5]); static void g(void); // internal linkage 

C ++

A la même sémantique, sauf dans la réponse courte. De plus, il n’y a pas de paramètre qualifiant static s.

 extern "C" { static void f4(); // the name of the function f4 has // internal linkage (not C language // linkage) and the function's type // has C language linkage. } class S { mutable static int i; // err mutable static int j; // err static int k; // ok, all instances share the same member }; inline void bar(void) { const static int x = 42; // ok static int y = -42; // ok } 

Il y a encore quelques nuances de static de C ++ que je laisse ici. Jetez un oeil à un livre ou à la norme.

Variables statiques:

  • Initialisé une seule fois
  • Les variables statiques sont pour la classe (pas par object). La mémoire est allouée une seule fois par classe et chaque instance l’utilise. Ainsi, si un object modifie sa valeur, la valeur modifiée est également visible pour les autres objects. (Une pensée simple .. Pour connaître le nombre d’objects créés pour une classe, on peut mettre une variable statique et do ++ dans le constructeur)
  • La valeur persiste entre les différents appels de fonction

Const Variables:

  • Les variables const sont une promesse que vous n’allez pas changer sa valeur dans le programme. Si vous le faites, il se plaindra.

Les constantes ne peuvent pas être modifiées, les variables statiques ont plus à voir avec la façon dont elles sont allouées et où elles sont accessibles.

Consultez ce site .

Les variables statiques dans le contexte d’une classe sont partagées entre toutes les instances d’une classe.

Dans une fonction, elle rest une variable persistante. Vous pouvez, par exemple, compter le nombre de fois où une fonction a été appelée.

Lorsqu’il est utilisé en dehors d’une fonction ou d’une classe, il garantit que la variable ne peut être utilisée que par le code dans ce fichier spécifique, et nulle part ailleurs.

Les variables constantes ne peuvent toutefois pas changer. Une utilisation courante de const et de static est dans une définition de classe pour fournir une sorte de constante.

 class myClass { public: static const int TOTAL_NUMBER = 5; // some public stuff private: // some stuff }; 

static signifie local pour l’unité de compilation (c.-à-d. un seul fichier de code source C ++) ou, en d’autres termes, il n’est pas ajouté à un espace de noms global. Vous pouvez avoir plusieurs variables statiques dans différents fichiers de code source c ++ portant le même nom et sans conflit de noms.

const est juste constant, le sens ne peut pas être modifié.

Une variable statique ne peut obtenir une valeur initiale qu’une seule fois. Cela signifie que si vous avez du code tel que ” static int a=0 ” dans une fonction exemple, et que ce code est exécuté dans un premier appel de cette fonction, mais pas dans un appel ultérieur de la fonction; La variable (a) aura toujours sa valeur actuelle (par exemple, une valeur actuelle de 5), car la variable statique ne reçoit une valeur initiale qu’une seule fois.

Une variable constante a sa valeur constante dans tout le code. Par exemple, si vous définissez la variable constante comme ” const int a=5 “, cette valeur pour “a” sera constante dans l’ensemble de votre programme.

const est équivalent à #define mais uniquement pour les instructions de valeur (par exemple, #define myvalue = 2 ). La valeur déclarée remplace le nom de la variable avant la compilation.

static est une variable. La valeur peut changer, mais la variable persistera tout au long de l’exécution du programme même si la variable est déclarée dans une fonction . Il est équivalent à une variable globale dont la scope d’utilisation est la scope du bloc dans lequel ils ont été déclarés, mais la scope de leur valeur est globale.

En tant que telles, les variables statiques ne sont initialisées qu’une seule fois . Ceci est particulièrement important si la variable est déclarée dans une fonction, car elle garantit que l’initialisation n’aura lieu qu’au premier appel à la fonction .

Un autre usage de la statique implique des objects. La déclaration d’une variable statique dans un object a pour effet que cette valeur est la même pour toutes les instances de l’object. En tant que tel, il ne peut pas être appelé avec le nom de l’object, mais uniquement avec le nom de la classe.

 public class Test { public static int test; } Test myTestObject=new Test(); myTestObject.test=2;//ERROR Test.test=2;//Correct 

Dans les langages comme C et C ++, il est inutile de déclarer des variables globales statiques, mais elles sont très utiles dans les fonctions et les classes. Dans les langages gérés, le seul moyen d’avoir l’effet d’une variable globale est de le déclarer statique.

Les variables statiques sont communes à toutes les instances d’un type.

Les variables constantes sont spécifiques à chaque instance individuelle d’un type, mais leurs valeurs sont connues et fixées au moment de la compilation et ne peuvent pas être modifiées à l’exécution.

Contrairement aux constantes, les valeurs des variables statiques peuvent être modifiées à l’exécution.

const signifie constant et leurs valeurs sont définies au moment de la compilation plutôt que de le modifier explicitement pendant l’exécution, la valeur de constante ne peut pas être modifiée pendant l’exécution

Cependant, les variables statiques sont des variables pouvant être initialisées et modifiées au moment de l’exécution. Cependant, les variables statiques sont différentes des variables en ce sens que les variables statiques conservent leurs valeurs pour l’ensemble du programme, c’est-à-dire que leur durée de vie est celle du programme ou jusqu’à ce que la Cependant, même s’ils conservent leurs valeurs pendant toute la durée de vie du programme, ils sont inaccessibles en dehors du bloc de code dans lequel ils se trouvent.

Pour plus d’informations sur les variables statiques, référez-vous ici

Les variables constantes ne peuvent pas être modifiées. Les variables statiques sont privées au fichier et accessibles uniquement dans le code du programme et non à quiconque.

mot-clé static définit la scope des variables, alors que le mot-clé const définit la valeur de la variable qui ne peut pas être modifiée lors de l’exécution du programme

La réponse simple et courte est que la mémoire est allouée pour static et const seulement une fois. Mais dans const, ce n’est que pour une valeur où les valeurs statiques peuvent changer, mais la zone de mémoire rest la même jusqu’à la fin du programme.

la valeur statique peut exister dans une fonction et peut être utilisée sous différentes formes et avoir une valeur différente dans le programme. De plus, pendant le programme après incrémentation de la décrémentation, leur valeur peut changer, mais constante dans tout le programme.