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 const?
Une valeur constante ne peut pas changer. Une variable statique existe pour une fonction ou une classe plutôt que pour une instance ou un objet.
Ces deux concepts ne sont pas mutuellement exclusifs et peuvent être utilisés ensemble.
La réponse courte:
Une 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'objet correspond à l'exécution complète du programme et que sa valeur n'est initialisée qu'une fois avant le démarrage du programme. Toutes les statiques sont initialisées si vous ne leur attribuez pas explicitement une valeur. La manière et le moment de l'initialisation statique sont non spécifié.
C99 a emprunté l'utilisation de const à C++. De plus, static a été la source de nombreux débats (dans les deux langues) en raison de sa sémantique souvent déroutante.
De même, avec C++ 0x jusqu'à C++ 11, l'utilisation du mot clé static était obsolète pour la déclaration d'objets dans la portée de l'espace de noms. Cette dépréciation a été supprimée en C++ 11 pour diverses raisons (voir ici ).
La réponse plus longue: plus sur les mots-clés que vous vouliez savoir (à partir des normes):
C99
#include <fenv.h>
#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 string 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 string 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 principalement sauf comme indiqué dans la réponse courte. De plus, il n'y a pas de paramètre qualifiant statics.
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 quelques autres nuances de static de C++ que je laisse ici. Regardez un livre ou la norme.
Variables statiques:
- Initialisé une seule fois.
- Les variables statiques sont pour la classe (pas par objet). C'est-à-dire que la mémoire n'est allouée qu'une fois par classe et que chaque instance l'utilise. Ainsi, si un objet modifie sa valeur, la valeur modifiée est également visible pour les autres objets. (Une simple pensée .. Pour connaître le nombre d'objets créés pour une classe, nous pouvons mettre une variable statique et do ++ dans le constructeur)
- La valeur persiste entre différents appels de fonction
Variables Const:
- Les variables const sont une promesse que vous n'allez pas changer sa valeur n'importe où dans le programme. Si vous le faites, il va se plaindre.
Les constantes ne peuvent pas être changées, les variables statiques ont plus à voir avec la façon dont elles sont allouées et où elles sont accessibles.
Découvrez 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 reste 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 de ce fichier spécifique, et nulle part ailleurs.
Les variables constantes ne peuvent toutefois pas changer. Une utilisation courante de const et static ensemble se trouve 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
};
const est équivalent à #define mais uniquement pour les instructions value (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. Cela équivaut à une variable globale dont la portée d'utilisation est la portée du bloc dans lequel ils ont été déclarés, mais la portée de leur valeur est globale.
En tant que telles, les variables statiques sont initialisées une seule fois}. Ceci est particulièrement important si la variable est déclarée dans une fonction, car cela garantit que l'initialisation n'aura lieu qu'au premier appel à la fonction.
Une autre utilisation de la statique concerne les objets. La déclaration d'une variable statique dans un objet a pour effet que cette valeur est la même pour toutes les instances de l'objet. En tant que tel, il ne peut pas être appelé avec le nom de l'objet, 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 des langages tels que C et C++, déclarer des variables globales statiques n'a pas de sens, mais elles sont très utiles dans les fonctions et les classes . .
static signifie local pour l'unité de compilation (c'est-à-dire un seul fichier de code source C++) ou, autrement dit, cela signifie qu'il n'est pas ajouté à un espace de noms global. vous pouvez avoir plusieurs variables statiques dans différents fichiers de code source c ++ avec les conflits same name et sans nom.
const est juste constant, le sens ne peut pas être modifié.
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 au moment de l'exécution.
contrairement aux constantes, les valeurs de variables statiques peuvent être modifiées au moment de l'exécution.
Une variable statique ne peut obtenir une valeur initiale qu'une fois. Cela signifie que si vous avez du code tel que "static int a=0" dans un exemple de fonction et que ce code est exécuté lors du 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 obtient une valeur initiale une fois seulement.
Une variable constante a sa valeur constante dans l'ensemble du code. Par exemple, si vous définissez la variable constante comme "const int a=5", la valeur de "a" sera constante dans l'ensemble de votre programme.
Le mot clé static définit la portée des variables alors que le mot clé const définit la valeur de la variable qui ne peut pas être modifiée pendant l'exécution du programme.
La réponse est simple et brève: la mémoire est allouée pour static et const une seule fois. Mais dans const, il ne s'agit que d'une valeur où, comme dans statique, les valeurs peuvent changer mais la zone mémoire reste la même jusqu'à la fin du programme.
statique
est utilisé pour faire de la variable une variable de classe. Vous n'avez pas besoin de définir une variable statique lors de la déclaration.
Exemple:
#include <iostream>
class dummy
{
public:
static int dum;
};
int dummy::dum = 0; //This is important for static variable, otherwise you'd get a linking error
int main()
{
dummy d;
d.dum = 1;
std::cout<<"Printing dum from object: "<<d.dum<<std::endl;
std::cout<<"Printing dum from class: "<<dummy::dum<<std::endl;
return 0;
}
Cela imprimerait: Imprimer un dum depuis un objet: 1 Imprimer un dum de la classe: 1
La variable dum est une variable de classe. Essayer d'y accéder via un objet informe simplement le compilateur qu'il s'agit d'une variable de quelle classe. Imaginez un scénario dans lequel vous pourriez utiliser une variable pour compter le nombre d'objets créés. l'électricité statique serait utile là-bas.
const
est utilisé pour en faire une variable en lecture seule. Vous devez définir et déclarer la variable const à la fois.
Dans le même programme mentionné ci-dessus, faisons en sorte que le dum soit un const:
class dummy
{
public:
static const int dum; // This would give an error. You need to define it as well
static const int dum = 1; //this is correct
const int dum = 1; //Correct. Just not making it a class variable
};
Supposons en gros que je fasse ceci:
int main()
{
dummy d;
d.dum = 1; //Illegal!
std::cout<<"Printing dum from object: "<<d.dum<<std::endl;
std::cout<<"Printing dum from class: "<<dummy::dum<<std::endl;
return 0;
}
Bien que statique ait été gérable à comprendre, const est foiré en c ++. La ressource suivante aide à mieux la comprendre: http://duramecho.com/ComputerInformation/WhyHowCppConst.html
Const signifie “ne peut pas être changé.”
Statique signifie “instance statique (en mémoire) vs instance dynamique (sur la pile.)”. Des variables statiques existent pour la durée du programme. Les dynamiques sont créées et détruites au besoin.
Une variable peut être une ou les deux.
Les variables constantes ne peuvent pas être changées. Les variables statiques sont privées du fichier et uniquement accessibles dans le code du programme et à aucune autre personne.
const signifie constante et que leurs valeurs sont définies au moment de la compilation plutôt que de les modifier explicitement pendant l'exécution également, la valeur de constante ne pouvant pas être modifiée pendant l'exécution
Cependant, les variables statiques sont des variables qui peuvent être initialisées et modifiées au moment de l'exécution. Cependant, les variables statiques diffèrent des variables dans le sens où les variables statiques conservent leurs valeurs pour l’ensemble du programme, c’est-à-dire que leur durée de vie appartient au programme ou jusqu’à ce que la mémoire soit allouée par le programme en utilisant la méthode d’allocation dynamique. 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