Le mot clé static - est celui qui a plusieurs significations en C ++ que je trouve très déroutant et je ne peux jamais penser à comment il est censé fonctionner.

D'après ce que je comprends, il y a staticla durée de stockage, ce qui signifie qu'elle dure toute la durée de vie du programme dans le cas d'un global, mais lorsque vous parlez d'un local, cela signifie que c'est zéro initialisé par défaut.

La norme C ++ dit ceci pour les membres de données de classe avec le mot-clé static:

3.7.1 Durée de stockage statique [basic.stc.static]

3 Le mot-clé statique peut être utilisé pour déclarer une variable locale avec une durée de stockage statique.

4 Le mot clé static appliqué à un membre de données de classe dans une définition de classe donne la durée de stockage statique du membre de données.

Qu'est-ce que cela signifie avec une variable locale ? Est-ce une variable locale de fonction? Parce qu'il y a aussi que lorsque vous déclarez une fonction locale commestatic elle n'est initialisée qu'une seule fois, la première fois qu'elle entre dans cette fonction.

Il ne parle également que de la durée de stockage en ce qui concerne les membres de la classe, qu'en est-il non spécifique à l'instance, c'est également une propriété de staticnon? Ou est-ce la durée de stockage?

Maintenant, qu'en est-il du cas staticet de la portée du fichier? Toutes les variables globales sont-elles considérées comme ayant une durée de stockage statique par défaut? Ce qui suit (extrait de la section 3.7.1) semble l'indiquer:

1 Toutes les variables qui n'ont pas de durée de stockage dynamique, n'ont pas de durée de stockage de thread et ne sont pas locales ont une durée de stockage statique. Le stockage de ces entités doit durer pendant la durée du programme (3.6.2, 3.6.3)

Quel est le staticlien avec le couplage d'une variable?

Tout ce staticmot-clé est carrément déroutant, quelqu'un peut-il clarifier les différentes utilisations de l'anglais et me dire quand initialiser un staticmembre de la classe?

Variables:

staticdes variables existent pour la "durée de vie" de l' unité de traduction dans laquelle elle est définie , et:

• S'il se trouve dans une étendue d'espace de noms (c'est-à-dire en dehors des fonctions et des classes), il n'est pas accessible à partir d'une autre unité de traduction. Ceci est connu sous le nom de "liaison interne" ou "durée de stockage statique". (Ne faites pas cela dans les en-têtes, sauf pourconstexpr . Autre chose, et vous vous retrouvez avec une variable distincte dans chaque unité de traduction, ce qui est complètement déroutant)
• S'il s'agit d'une variable dans une fonction , elle n'est pas accessible depuis l'extérieur de la fonction, comme toute autre variable locale. (c'est le local qu'ils ont mentionné)
• Les membres de la classe n'ont pas de portée restreinte en raison de static, mais peuvent être adressés à partir de la classe ainsi que d'une instance (comme std::string::npos). [Remarque: vous pouvez déclarer des membres statiques dans une classe, mais ils doivent généralement être définis dans une unité de traduction (fichier cpp), et en tant que tel, il n'y en a qu'un par classe]

emplacements comme code:

static std::string namespaceScope = "Hello";
void foo() {
    static std::string functionScope= "World";
}
struct A {
   static std::string classScope = "!";
};

Avant l' mainexécution de toute fonction dans une unité de traduction (éventuellement après le début de l'exécution), les variables avec une durée de stockage statique (étendue de l'espace de noms) dans cette unité de traduction seront "constamment initialisées" (dans la mesure du constexprpossible, ou zéro sinon), puis non les sections locales sont «initialisées dynamiquement» correctement dans l'ordre dansstd::string="HI"; lequel elles sont définies dans l'unité de traduction (pour des choses comme cela ne le sont pas constexpr). Enfin, les statiques fonctionnelles locales seront initialisées la première fois que l'exécution "atteint" la ligne où elles sont déclarées. Toutes les staticvariables sont toutes détruites dans l'ordre inverse de l'initialisation.

Le moyen le plus simple pour obtenir tout cela est de faire en sorte que toutes les variables statiques qui ne sont pas constexprinitialisées en fonction locals statiques, ce qui garantit que toutes vos statistiques / globales sont initialisées correctement lorsque vous essayez de les utiliser quoi qu'il arrive, empêchant ainsi l' initialisation statique commander le fiasco .

T& get_global() {
    static T global = initial_value();
    return global;
}

Soyez prudent, car lorsque la spécification indique que les variables de portée d'espace de noms ont par défaut "durée de stockage statique", elles signifient le bit "durée de vie de l'unité de traduction", mais cela ne signifie pas qu'il ne peut pas être consulté en dehors du fichier.

Les fonctions

Significativement plus simple, staticest souvent utilisé comme fonction de membre de classe, et très rarement utilisé pour une fonction autonome.

Une fonction membre statique diffère d'une fonction membre régulière en ce qu'elle peut être appelée sans instance d'une classe, et comme elle n'a pas d'instance, elle ne peut pas accéder aux membres non statiques de la classe. Les variables statiques sont utiles lorsque vous souhaitez avoir une fonction pour une classe qui ne fait absolument référence à aucun membre d'instance ou pour gérer staticles variables de membre.

struct A {
    A() {++A_count;}
    A(const A&) {++A_count;}
    A(A&&) {++A_count;}
    ~A() {--A_count;}

    static int get_count() {return A_count;}
private:
    static int A_count;
}

int main() {
    A var;

    int c0 = var.get_count(); //some compilers give a warning, but it's ok.
    int c1 = A::get_count(); //normal way
}

Une staticfonction libre signifie que la fonction ne sera référencée par aucune autre unité de traduction, et donc l'éditeur de liens peut l'ignorer complètement. Cela a un petit nombre d'objectifs:

• Peut être utilisé dans un fichier cpp pour garantir que la fonction n'est jamais utilisée à partir d'un autre fichier.
• Peut être placé dans un en-tête et chaque fichier aura sa propre copie de la fonction. Pas utile, car inline fait à peu près la même chose.
• Accélère le temps de liaison en réduisant le travail
• Peut mettre une fonction avec le même nom dans chaque unité de traduction, et ils peuvent tous faire des choses différentes. Par exemple, vous pouvez mettre un static void log(const char*) {}dans chaque fichier cpp, et ils peuvent tous se connecter de manière différente.

La durée de stockage statique signifie que la variable réside au même endroit en mémoire pendant toute la durée de vie du programme.

Le lien est orthogonal à cela.

Je pense que c'est la distinction la plus importante que vous puissiez faire. Comprendre cela et le reste, ainsi que s'en souvenir, devrait être facile (ne pas s'adresser directement à @Tony, mais à quiconque pourrait le lire à l'avenir).

Le mot-clé staticpeut être utilisé pour désigner la liaison interne et le stockage statique, mais en substance, ils sont différents.

Qu'est-ce que cela signifie avec une variable locale? Est-ce une variable locale de fonction?

Oui. Quel que soit le moment où la variable est initialisée (lors du premier appel à la fonction et lorsque le chemin d'exécution atteint le point de déclaration), elle résidera au même endroit en mémoire pendant toute la durée de vie du programme. Dans ce cas, staticlui donne un stockage statique.

Maintenant, qu'en est-il du cas avec la portée statique et de fichier? Toutes les variables globales sont-elles considérées comme ayant une durée de stockage statique par défaut?

Oui, tous les globaux ont par définition une durée de stockage statique (maintenant que nous avons clarifié ce que cela signifie). Mais les variables de portée d'espace de noms ne sont pas déclarées avec static, car cela leur donnerait un lien interne, donc une variable par unité de traduction.

Quel est le lien entre statique et liaison d'une variable?

Il fournit un lien interne aux variables de portée d'espace de noms. Il donne aux membres et aux variables locales une durée de stockage statique.

Développons tout cela:

//

static int x; //internal linkage
              //non-static storage - each translation unit will have its own copy of x
              //NOT A TRUE GLOBAL!

int y;        //static storage duration (can be used with extern)
              //actual global
              //external linkage
struct X
{
   static int x;     //static storage duration - shared between class instances 
};

void foo()
{
   static int x;     //static storage duration - shared between calls
}

Tout ce mot-clé statique est carrément déroutant

Certainement, à moins que vous ne le connaissiez. :) Essayant d'éviter d'ajouter de nouveaux mots clés à la langue, le comité a réutilisé celui-ci, l'OMI, à cet effet - confusion. Il est utilisé pour signifier différentes choses (pourrais-je dire, probablement des choses opposées).

Afin de clarifier la question, je préfère classer l'utilisation du mot-clé «statique» sous trois formes différentes:

(UNE). les variables

(B). les fonctions

(C). Variables membres / fonctions des classes

l'explication ci-dessous pour chacune des sous-rubriques:

(A) mot-clé 'statique' pour les variables

Celui-ci peut être peu délicat, mais s'il est expliqué et compris correctement, il est assez simple.

Pour expliquer cela, il est d'abord très utile de connaître la portée, la durée et le lien des variables, sans lesquelles les choses sont toujours difficiles à voir à travers le concept trouble du mot-clé staic

1. Portée : détermine où dans le fichier, la variable est accessible. Il peut être de deux types: (i) Portée locale ou étendue . (ii) Portée mondiale

2. Durée : détermine quand une variable est créée et détruite. Encore une fois, il est de deux types: (i) Durée de stockage automatique (pour les variables ayant une portée locale ou bloc). (ii) Durée de stockage statique (pour les variables ayant une portée globale ou des variables locales (dans une fonction ou dans un bloc de code) avec spécificateur statique ).

3. Lien : détermine si une variable est accessible (ou liée) dans un autre fichier. Encore une fois (et heureusement), il est de deux types: (i) Liaison interne (pour les variables ayant une portée de bloc et une portée globale / portée de fichier / portée globale de l'espace de noms) (ii) Liaison externe (pour les variables n'ayant qu'une portée globale / portée de fichier / Portée de l'espace de noms global)

Voyons un exemple ci-dessous pour une meilleure compréhension des variables globales et locales simples (pas de variables locales avec une durée de stockage statique):

//main file
#include <iostream>

int global_var1; //has global scope
const global_var2(1.618); //has global scope

int main()
{
//these variables are local to the block main.
//they have automatic duration, i.e, they are created when the main() is 
//  executed and destroyed, when main goes out of scope
 int local_var1(23);
 const double local_var2(3.14);

 {
/* this is yet another block, all variables declared within this block are 
 have local scope limited within this block. */
// all variables declared within this block too have automatic duration, i.e, 
/*they are created at the point of definition within this block,
 and destroyed as soon as this block ends */
   char block_char1;
   int local_var1(32) //NOTE: this has been re-declared within the block, 
//it shadows the local_var1 declared outside

 std::cout << local_var1 <<"\n"; //prints 32

  }//end of block
  //local_var1 declared inside goes out of scope

 std::cout << local_var1 << "\n"; //prints 23

 global_var1 = 29; //global_var1 has been declared outside main (global scope)
 std::cout << global_var1 << "\n"; //prints 29
 std::cout << global_var2 << "\n"; //prints 1.618

 return 0;
}  //local_var1, local_var2 go out of scope as main ends
//global_var1, global_var2 go out of scope as the program terminates 
//(in this case program ends with end of main, so both local and global
//variable go out of scope together

Maintenant vient le concept de Linkage. Lorsqu'une variable globale définie dans un fichier est destinée à être utilisée dans un autre fichier, le lien de la variable joue un rôle important.

Le couplage des variables globales est spécifié par les mots clés: (i) statique , et, (ii) extern

(Maintenant, vous obtenez l'explication)

un mot-clé statique peut être appliqué à des variables de portée locale et globale, et dans les deux cas, elles signifient des choses différentes. J'expliquerai d'abord l'utilisation du mot-clé «statique» dans les variables à portée globale (où je clarifie également l'utilisation du mot-clé «extern») et ensuite pour celles à portée locale.

1. Mot-clé statique pour les variables de portée globale

Les variables globales ont une durée statique, ce qui signifie qu'elles ne sortent pas du champ d'application lorsqu'un bloc de code particulier (par exemple, main ()) dans lequel il est utilisé se termine. Selon le lien, ils sont accessibles uniquement dans le même fichier où ils sont déclarés (pour la variable globale statique), ou en dehors du fichier même en dehors du fichier dans lequel ils sont déclarés (variables globales de type externe)

Dans le cas d'une variable globale ayant un spécificateur externe, et si cette variable est accessible en dehors du fichier dans lequel elle a été initialisée, elle doit être déclarée en avant dans le fichier où elle est utilisée, tout comme une fonction doit être en avant déclaré si sa définition se trouve dans un fichier différent de celui où elle est utilisée.

En revanche, si la variable globale a un mot-clé statique, elle ne peut pas être utilisée dans un fichier en dehors duquel elle a été déclarée.

(voir l'exemple ci-dessous pour des éclaircissements)

par exemple:

//main2.cpp
 static int global_var3 = 23;  /*static global variable, cannot be                            
                                accessed in anyother file */
 extern double global_var4 = 71; /*can be accessed outside this file                  linked to main2.cpp */
 int main() { return 0; }

main3.cpp

//main3.cpp
#include <iostream>

int main()
{
   extern int gloabl_var4; /*this variable refers to the gloabal_var4
                            defined in the main2.cpp file */
  std::cout << global_var4 << "\n"; //prints 71;

  return 0;
}

maintenant, toute variable en c ++ peut être soit un const, soit un non-const et pour chaque 'const-ness' nous obtenons deux cas de liaison c ++ par défaut, au cas où aucun n'est spécifié:

(i) Si une variable globale est non-const, son lien est extern par défaut , c'est-à-dire que la variable globale non-const est accessible dans un autre fichier .cpp par déclaration directe à l'aide du mot-clé extern (en d'autres termes, non const global les variables ont un lien externe (avec une durée statique bien sûr)). L'utilisation du mot-clé extern dans le fichier d'origine où il a été défini est également redondante. Dans ce cas, pour rendre une variable globale non const inaccessible au fichier externe, utilisez le spécificateur «statique» avant le type de la variable .

(ii) Si une variable globale est const, son lien est statique par défaut , c'est-à-dire qu'une variable globale const n'est pas accessible dans un fichier autre que celui où elle est définie, (en d'autres termes, les variables globales const ont un lien interne (avec une durée statique) bien sûr)). L'utilisation d'un mot-clé statique pour empêcher l'accès à une variable globale const dans un autre fichier est également redondante. Ici, pour faire en sorte qu'une variable globale const ait un lien externe, utilisez le spécificateur 'extern' avant le type de la variable

Voici un résumé des variables de portée globale avec divers liens

//globalVariables1.cpp 

// defining uninitialized vairbles
int globalVar1; //  uninitialized global variable with external linkage 
static int globalVar2; // uninitialized global variable with internal linkage
const int globalVar3; // error, since const variables must be initialized upon declaration
const int globalVar4 = 23; //correct, but with static linkage (cannot be accessed outside the file where it has been declared*/
extern const double globalVar5 = 1.57; //this const variable ca be accessed outside the file where it has been declared

Ensuite, nous étudions le comportement des variables globales ci-dessus lorsqu'elles sont accessibles dans un fichier différent.

//using_globalVariables1.cpp (eg for the usage of global variables above)

// Forward declaration via extern keyword:
 extern int globalVar1; // correct since globalVar1 is not a const or static
 extern int globalVar2; //incorrect since globalVar2 has internal linkage
 extern const int globalVar4; /* incorrect since globalVar4 has no extern 
                         specifier, limited to internal linkage by
                         default (static specifier for const variables) */
 extern const double globalVar5; /*correct since in the previous file, it 
                           has extern specifier, no need to initialize the
                       const variable here, since it has already been
                       legitimately defined perviously */

2. Mot-clé statique pour les variables avec portée locale

Mises à jour (août 2019) du mot clé statique pour les variables de portée locale

Cela peut encore être subdivisé en deux catégories:

(i) mot clé statique pour les variables d'un bloc fonctionnel , et (ii) mot clé statique pour les variables d'un bloc local sans nom.

(i) mot-clé statique pour les variables d'un bloc fonctionnel.

Plus tôt, j'ai mentionné que les variables de portée locale ont une durée automatique, c'est-à-dire qu'elles commencent à exister lorsque le bloc est entré (que ce soit un bloc normal, que ce soit un bloc fonctionnel) et cessent d'exister lorsque le bloc se termine, bref, les variables avec portée locale ont une durée automatique et les variables de durée automatiques (et les objets) n'ont pas de lien, ce qui signifie qu'ils ne sont pas visibles en dehors du bloc de code.

Si un spécificateur statique est appliqué à une variable locale dans un bloc fonctionnel, il modifie la durée de la variable automatique en statique et sa durée de vie est la durée totale du programme, ce qui signifie qu'il a un emplacement de mémoire fixe et que sa valeur est initialisée uniquement une fois avant le démarrage du programme comme mentionné dans la référence cpp (l'initialisation ne doit pas être confondue avec l'affectation)

permet de jeter un oeil à un exemple.

//localVarDemo1.cpp    
 int localNextID()
{
  int tempID = 1;  //tempID created here
  return tempID++; //copy of tempID returned and tempID incremented to 2
} //tempID destroyed here, hence value of tempID lost

int newNextID()
{
  static int newID = 0;//newID has static duration, with internal linkage
  return newID++; //copy of newID returned and newID incremented by 1
}  //newID doesn't get destroyed here :-)


int main()
{
  int employeeID1 = localNextID();  //employeeID1 = 1
  int employeeID2 = localNextID();  // employeeID2 = 1 again (not desired)
  int employeeID3 = newNextID(); //employeeID3 = 0;
  int employeeID4 = newNextID(); //employeeID4 = 1;
  int employeeID5 = newNextID(); //employeeID5 = 2;
  return 0;
}

En examinant le critère ci-dessus pour les variables locales statiques et les variables globales statiques, on pourrait être tenté de se demander quelle pourrait être la différence entre elles. Alors que les variables globales sont accessibles à tout moment dans le code (dans la même unité de traduction que dans différentes selon la const -ness et l' extern -ness), une variable statique définie dans un bloc fonction n'est pas directement accessible. La variable doit être renvoyée par la valeur ou la référence de la fonction. Voyons cela par un exemple:

//localVarDemo2.cpp 

//static storage duration with global scope 
//note this variable can be accessed from outside the file
//in a different compilation unit by using `extern` specifier
//which might not be desirable for certain use case.
static int globalId = 0;

int newNextID()
{
  static int newID = 0;//newID has static duration, with internal linkage
  return newID++; //copy of newID returned and newID incremented by 1
}  //newID doesn't get destroyed here


int main()
{
    //since globalId is accessible we use it directly
  const int globalEmployee1Id = globalId++; //globalEmployeeId1 = 0;
  const int globalEmployee2Id = globalId++; //globalEmployeeId1 = 1;

  //const int employeeID1 = newID++; //this will lead to compilation error since newID++ is not accessible direcly. 
  int employeeID2 = newNextID(); //employeeID3 = 0;
  int employeeID2 = newNextID(); //employeeID3 = 1;

  return 0;
}

Plus d'explications sur le choix de la variable statique globale et statique locale peuvent être trouvées sur ce thread stackoverflow

(ii) mot-clé statique pour les variables dans un bloc local sans nom.

les variables statiques dans un bloc local (pas un bloc fonctionnel) ne sont pas accessibles en dehors du bloc une fois que le bloc local est hors de portée. Aucune mise en garde à cette règle.

    //localVarDemo3.cpp 
    int main()
    {

      {
          const static int static_local_scoped_variable {99};
      }//static_local_scoped_variable goes out of scope

      //the line below causes compilation error
      //do_something is an arbitrary function
      do_something(static_local_scoped_variable);
      return 0;
    }

C ++ 11 a introduit le mot-clé constexprqui garantit l'évaluation d'une expression au moment de la compilation et permet au compilateur d'optimiser le code. Maintenant, si la valeur d'une variable statique const dans une étendue est connue au moment de la compilation, le code est optimisé d'une manière similaire à celle avec constexpr. Voici un petit exemple

Je recommande également aux lecteurs de rechercher la différence entre constexpret static constpour les variables dans ce thread stackoverflow . ceci conclut mon explication du mot-clé statique appliqué aux variables.

Mot-clé 'statique' utilisé pour les fonctions

en termes de fonctions, le mot-clé statique a une signification simple. Ici, il se réfère à la liaison de la fonction Normalement, toutes les fonctions déclarées dans un fichier cpp ont un lien externe par défaut, c'est-à-dire qu'une fonction définie dans un fichier peut être utilisée dans un autre fichier cpp par déclaration directe.

l'utilisation d'un mot clé statique avant la déclaration de fonction limite son lien à interne , c'est-à-dire qu'une fonction statique ne peut pas être utilisée dans un fichier en dehors de sa définition.

C. Mot-clé Staitc utilisé pour les variables membres et les fonctions des classes

1. mot clé "statique" pour les variables membres des classes

Je commence directement avec un exemple ici

#include <iostream>

class DesignNumber
{
  private:

      static int m_designNum;  //design number
      int m_iteration;     // number of iterations performed for the design

  public:
    DesignNumber() {     }  //default constructor

   int  getItrNum() //get the iteration number of design
   {
      m_iteration = m_designNum++;
      return m_iteration;
   }
     static int m_anyNumber;  //public static variable
};
int DesignNumber::m_designNum = 0; // starting with design id = 0
                     // note : no need of static keyword here
                     //causes compiler error if static keyword used
int DesignNumber::m_anyNumber = 99; /* initialization of inclass public 
                                    static member  */
enter code here

int main()
{
   DesignNumber firstDesign, secondDesign, thirdDesign;
   std::cout << firstDesign.getItrNum() << "\n";  //prints 0
   std::cout << secondDesign.getItrNum() << "\n"; //prints 1
   std::cout << thirdDesign.getItrNum() << "\n";  //prints 2

   std::cout << DesignNumber::m_anyNumber++ << "\n";  /* no object
                                        associated with m_anyNumber */
   std::cout << DesignNumber::m_anyNumber++ << "\n"; //prints 100
   std::cout << DesignNumber::m_anyNumber++ << "\n"; //prints 101

   return 0;
}

Dans cet exemple, la variable statique m_designNum conserve sa valeur et cette seule variable membre privée (car elle est statique) est partagée n / b toutes les variables du type d'objet DesignNumber

De même que les autres variables membres, les variables membres statiques d'une classe ne sont associées à aucun objet de classe, ce qui est démontré par l'impression de anyNumber dans la fonction principale

const vs variables de membres statiques non const dans la classe

(i) Variables de membre statique de classe non const Dans l'exemple précédent, les membres statiques (publics et privés) n'étaient pas constants. La norme ISO interdit l'initialisation des membres statiques non const dans la classe. Par conséquent, comme dans l'exemple précédent, ils doivent être initialisés après la définition de classe, avec la mise en garde que le mot clé statique doit être omis

(ii) les variables membres const-stat de la classe ceci est simple et va avec la convention de l'initialisation des autres variables membres const, c'est-à-dire que les variables membres stat const d'une classe peuvent être initialisées au point de déclaration et elles peuvent être initialisées à la fin de la déclaration de classe avec une mise en garde que le mot clé const doit être ajouté au membre statique lors de son initialisation après la définition de classe.

Je recommanderais cependant d'initialiser les variables de membre statique const au point de déclaration. Cela va avec la convention C ++ standard et rend le code plus propre

pour plus d'exemples sur les variables membres statiques dans une classe, recherchez le lien suivant sur learncpp.com http://www.learncpp.com/cpp-tutorial/811-static-member-variables/

2. Mot clé "statique" pour la fonction membre des classes

Tout comme les variables membres des classes peuvent être statiques, les fonctions membres des classes peuvent également l'être. Les fonctions membres normales des classes sont toujours associées à un objet du type classe. En revanche, les fonctions membres statiques d'une classe ne sont associées à aucun objet de la classe, c'est-à-dire qu'elles n'ont pas * ce pointeur.

Deuxièmement, puisque les fonctions membres statiques de la classe n'ont pas * ce pointeur, elles peuvent être appelées à l'aide de l'opérateur de résolution de nom et de portée de classe dans la fonction principale (ClassName :: functionName ();)

Troisièmement, les fonctions membres statiques d'une classe ne peuvent accéder qu'aux variables membres statiques d'une classe, car les variables membres non statiques d'une classe doivent appartenir à un objet de classe.

pour plus d'exemples sur les fonctions membres statiques dans une classe, recherchez le lien suivant sur learncpp.com

http://www.learncpp.com/cpp-tutorial/812-static-member-functions/

C'est en fait assez simple. Si vous déclarez une variable comme statique dans la portée d'une fonction, sa valeur est préservée entre les appels successifs à cette fonction. Alors:

int myFun()
{
static int i=5;
i++;
return i;
}
int main()
{
printf("%d", myFun());
printf("%d", myFun());
printf("%d", myFun());
}

s'affichera 678au lieu de 666, car il se souvient de la valeur incrémentée.

Quant aux membres statiques, ils conservent leur valeur dans toutes les instances de la classe. Donc le code suivant:

struct A
{
static int a;
};
int main()
{
A first;
A second;
first.a = 3;
second.a = 4;
printf("%d", first.a);
}

affichera 4, car first.a et second.a sont essentiellement la même variable. Quant à l'initialisation, voir cette question.

Lorsque vous déclarez une staticvariable à la portée du fichier, cette variable n'est disponible que dans que ce fichier particulier (techniquement, l'unité de traduction *, mais ne compliquons pas cela trop). Par exemple:

a.cpp

static int x = 7;

void printax()
{
    cout << "from a.cpp: x=" << x << endl;
}

b.cpp

static int x = 9;

void printbx()
{
    cout << "from b.cpp: x=" << x << endl;
}

main.cpp:

int main(int, char **)
{
    printax(); // Will print 7
    printbx(); // Will print 9

    return 0;
}

Pour une variable locale , staticsignifie que la variable sera initialisée à zéro et conservera sa valeur entre les appels:

unsigned int powersoftwo()
{
    static unsigned lastpow;

    if(lastpow == 0)
        lastpow = 1;
    else
        lastpow *= 2;

    return lastpow;
}

int main(int, char **)
{
    for(int i = 0; i != 10; i++)
        cout << "2^" << i << " = " << powersoftwo() << endl;
}

Pour les variables de classe , cela signifie qu'il n'y a qu'une seule instance de cette variable qui est partagée entre tous les membres de cette classe. Selon les autorisations, la variable est accessible depuis l'extérieur de la classe en utilisant son nom complet.

class Test
{
private:
    static char *xxx;

public:
    static int yyy;

public:
    Test()
    {        
        cout << this << "The static class variable xxx is at address "
             << static_cast<void *>(xxx) << endl;
        cout << this << "The static class variable yyy is at address "
             << static_cast<void *>(&y) << endl;
    }
};

// Necessary for static class variables.
char *Test::xxx = "I'm Triple X!";
int Test::yyy = 0;

int main(int, char **)
{
    Test t1;
    Test t2;

    Test::yyy = 666;

    Test t3;
};

Marquage d'une fonction non-classe comme static rend la fonction uniquement accessible à partir de ce fichier et inaccessible à partir d'autres fichiers.

a.cpp

static void printfilename()
{ // this is the printfilename from a.cpp - 
  // it can't be accessed from any other file
    cout << "this is a.cpp" << endl;
}

b.cpp

static void printfilename()
{ // this is the printfilename from b.cpp - 
  // it can't be accessed from any other file
    cout << "this is b.cpp" << endl;
}

Pour les fonctions membres de la classe, les marquer comme staticsignifie que la fonction n'a pas besoin d'être appelée sur une instance particulière d'un objet (c'est-à-dire qu'elle n'a pas de thispointeur).

class Test
{
private:
    static int count;

public:
    static int GetTestCount()
    {
        return count;
    };

    Test()
    {
        cout << this << "Created an instance of Test" << endl;
        count++;
    }

    ~Test()
    {
        cout << this << "Destroyed an instance of Test" << endl;
        count--;
    }
};

int Test::count = 0;

int main(int, char **)
{
    Test *arr[10] = { NULL };

    for(int i = 0; i != 10; i++)
        arr[i] = new Test();

    cout << "There are " << Test::GetTestCount() << " instances of the Test class!" << endl;

    // now, delete them all except the first and last!
    for(int i = 1; i != 9; i++)
        delete arr[i];        

    cout << "There are " << Test::GetTestCount() << " instances of the Test class!" << endl;

    delete arr[0];

    cout << "There are " << Test::GetTestCount() << " instances of the Test class!" << endl;

    delete arr[9];

    cout << "There are " << Test::GetTestCount() << " instances of the Test class!" << endl;

    return 0;
}

Les variables statiques sont partagées entre chaque instance d'une classe, au lieu que chaque classe ait sa propre variable.

class MyClass
{
    public:
    int myVar; 
    static int myStaticVar;
};

//Static member variables must be initialized. Unless you're using C++11, or it's an integer type,
//they have to be defined and initialized outside of the class like this:
MyClass::myStaticVar = 0;

MyClass classA;
MyClass classB;

Chaque instance de «MyClass» a son propre «myVar», mais partage le même «myStaticVar». En fait, vous n'avez même pas besoin d'une instance de MyClass pour accéder à 'myStaticVar', et vous pouvez y accéder en dehors de la classe comme ceci:

MyClass::myStaticVar //Assuming it's publicly accessible.

Lorsqu'il est utilisé dans une fonction en tant que variable locale (et non en tant que variable membre d'une classe), le mot clé statique fait quelque chose de différent. Il vous permet de créer une variable persistante, sans donner de portée globale.

int myFunc()
{
   int myVar = 0; //Each time the code reaches here, a new variable called 'myVar' is initialized.
   myVar++;

   //Given the above code, this will *always* print '1'.
   std::cout << myVar << std::endl;

   //The first time the code reaches here, 'myStaticVar' is initialized. But ONLY the first time.
   static int myStaticVar = 0;

   //Each time the code reaches here, myStaticVar is incremented.
   myStaticVar++;

   //This will print a continuously incrementing number,
   //each time the function is called. '1', '2', '3', etc...
   std::cout << myStaticVar << std::endl;
}

C'est une variable globale en termes de persistance ... mais sans être globale en portée / accessibilité.

Vous pouvez également avoir des fonctions membres statiques. Les fonctions statiques sont essentiellement des fonctions non membres, mais à l'intérieur de l'espace de noms du nom de classe, et avec un accès privé aux membres de la classe.

class MyClass
{
    public:
    int Func()
    {
        //...do something...
    }

    static int StaticFunc()
    {
        //...do something...
    }
};

int main()
{
   MyClass myClassA;
   myClassA.Func(); //Calls 'Func'.
   myClassA.StaticFunc(); //Calls 'StaticFunc'.

   MyClass::StaticFunc(); //Calls 'StaticFunc'.
   MyClass::Func(); //Error: You can't call a non-static member-function without a class instance!

   return 0;
}

Lorsque vous appelez une fonction membre, il y a un paramètre caché appelé «this», c'est-à-dire un pointeur vers l'instance de la classe appelant la fonction. Les fonctions membres statiques n'ont pas ce paramètre caché ... elles peuvent être appelées sans instance de classe, mais ne peuvent pas non plus accéder aux variables membres non statiques d'une classe, car elles n'ont pas de pointeur «this» avec lequel travailler. Ils ne sont appelés sur aucune instance de classe spécifique.

Je ne suis pas un programmeur C, donc je ne peux pas vous donner correctement des informations sur l'utilisation de statique dans un programme C, mais en ce qui concerne la programmation orientée objet, static déclare fondamentalement qu'une variable, une fonction ou une classe est la même pendant toute la durée du programme. Prends pour exemple.

class A
{
public:
    A();
    ~A();
    void somePublicMethod();
private:
    void somePrivateMethod();
};

Lorsque vous instanciez cette classe dans votre Main, vous faites quelque chose comme ça.

int main()
{
   A a1;
   //do something on a1
   A a2;
   //do something on a2
}

Ces deux instances de classe sont complètement différentes l'une de l'autre et fonctionnent indépendamment l'une de l'autre. Mais si vous deviez recréer la classe A comme ça.

class A
{
public:
    A();
    ~A();
    void somePublicMethod();
    static int x;
private:
    void somePrivateMethod();
};

Revenons à nouveau au principal.

int main()
{
   A a1;
   a1.x = 1;
   //do something on a1
   A a2;
   a2.x++;
   //do something on a2
}

Alors a1 et a2 partageraient la même copie de int x, de sorte que toute opération sur x dans a1 influencerait directement les opérations de x dans a2. Donc, si je devais faire ça

int main()
{
   A a1;
   a1.x = 1;
   //do something on a1
   cout << a1.x << endl; //this would be 1
   A a2;
   a2.x++;
   cout << a2.x << endl; //this would be 2 
   //do something on a2
}

Les deux instances de la classe A partagent des variables et des fonctions statiques. J'espère que ça répond à ta question. Ma connaissance limitée de C me permet de dire que la définition d'une fonction ou d'une variable comme statique signifie que le fichier est uniquement visible dans lequel la fonction ou la variable est définie comme statique. Mais cela serait mieux répondu par un gars C et pas moi. C ++ permet à la fois C et C ++ de déclarer vos variables comme statiques car il est complètement rétrocompatible avec C.

Qu'est-ce que cela signifie avec une variable locale? Est-ce une variable locale de fonction?

Oui - Non global, comme une variable locale de fonction.

Parce qu'il y a aussi que lorsque vous déclarez une fonction locale comme statique, elle n'est initialisée qu'une seule fois, la première fois qu'elle entre dans cette fonction.

Droite.

Il ne parle également que de la durée de stockage en ce qui concerne les membres de la classe, qu'en est-il non spécifique à l'instance, c'est également une propriété de non statique? Ou est-ce la durée de stockage?

class R { static int a; }; // << static lives for the duration of the program

c'est-à-dire que toutes les instances de Rpartage int R::a- int R::ane sont jamais copiées.

Maintenant, qu'en est-il du cas avec la portée statique et de fichier?

Effectivement un global qui a constructeur / destructeur le cas échéant - l'initialisation n'est pas différée jusqu'à l'accès.

Quel est le lien entre statique et liaison d'une variable?

Pour une fonction locale, elle est externe. Accès: Il est accessible à la fonction (à moins bien sûr que vous ne la renvoyiez).

Pour une classe, c'est externe. Accès: des spécificateurs d'accès standard s'appliquent (public, protégé, privé).

static peut également spécifier un lien interne, selon l'endroit où il est déclaré (fichier / espace de noms).

Tout ce mot-clé statique est carrément déroutant

Il a trop de fonctions en C ++.

quelqu'un peut-il clarifier les différentes utilisations de l'anglais et me dire quand initialiser un membre de classe statique?

Il est automatiquement initialisé avant mains'il est chargé et possède un constructeur. Cela peut sembler une bonne chose, mais l'ordre d'initialisation est largement hors de votre contrôle, donc l'initialisation complexe devient très difficile à maintenir, et vous voulez minimiser cela - si vous devez avoir une statique, alors les échelles locales fonctionnent bien mieux dans les bibliothèques et projets. En ce qui concerne les données avec une durée de stockage statique, vous devez essayer de minimiser cette conception, en particulier si elle est modifiable (variables globales). Le «temps» d'initialisation varie également pour un certain nombre de raisons - le chargeur et le noyau ont quelques astuces pour minimiser l'empreinte mémoire et différer l'initialisation, en fonction des données en question.

Objet statique: nous pouvons définir des membres de classe statiques à l'aide d'un mot clé statique. Lorsque nous déclarons un membre d'une classe comme statique, cela signifie que peu importe le nombre d'objets de la classe créés, il n'y a qu'une seule copie du membre statique.

Un membre statique est partagé par tous les objets de la classe. Toutes les données statiques sont initialisées à zéro lorsque le premier objet est créé, si aucune autre initialisation n'est présente. Nous ne pouvons pas le mettre dans la définition de classe, mais il peut être initialisé en dehors de la classe comme dans l'exemple suivant en redéclarant la variable statique, en utilisant l'opérateur de résolution de portée :: pour identifier à quelle classe il appartient.

Essayons l'exemple suivant pour comprendre le concept de membres de données statiques:

#include <iostream>

using namespace std;

class Box
{
   public:
      static int objectCount;
      // Constructor definition
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // Increase every time object is created
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
   private:
      double length;     // Length of a box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};

// Initialize static member of class Box
int Box::objectCount = 0;

int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2

   // Print total number of objects.
   cout << "Total objects: " << Box::objectCount << endl;

   return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Constructor called.
Constructor called.
Total objects: 2

Membres de fonction statiques: en déclarant un membre de fonction statique, vous le rendez indépendant de tout objet particulier de la classe. Une fonction membre statique peut être appelée même si aucun objet de la classe n'existe et que les fonctions statiques sont accessibles en utilisant uniquement le nom de classe et l'opérateur de résolution de portée ::.

Une fonction membre statique ne peut accéder qu'aux membres de données statiques, aux autres fonctions membres statiques et à toute autre fonction extérieure à la classe.

Les fonctions membres statiques ont une portée de classe et n'ont pas accès au pointeur this de la classe. Vous pouvez utiliser une fonction membre statique pour déterminer si certains objets de la classe ont été créés ou non.

Essayons l'exemple suivant pour comprendre le concept de membres de fonction statiques:

#include <iostream>

using namespace std;

class Box
{
   public:
      static int objectCount;
      // Constructor definition
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // Increase every time object is created
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
      static int getCount()
      {
         return objectCount;
      }
   private:
      double length;     // Length of a box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};

// Initialize static member of class Box
int Box::objectCount = 0;

int main(void)
{

   // Print total number of objects before creating object.
   cout << "Inital Stage Count: " << Box::getCount() << endl;

   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2

   // Print total number of objects after creating object.
   cout << "Final Stage Count: " << Box::getCount() << endl;

   return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Inital Stage Count: 0
Constructor called.
Constructor called.
Final Stage Count: 2