Que signifie exactement « statique » signifie la déclaration des variables « globales » dans C ++?

Question

Ceci est une extension du champ d'application a

Était-ce utile?

Nous faire parvenir

La solution

Le static mot a des significations différentes dans C ++, en fonction du contexte.

Lorsque vous déclarez une fonction libre ou une variable globale, cela signifie que la fonction est de ne pas être disponible en dehors de cette unité de traduction simple:

// test.cpp
static int a = 1;
static void foo() {}

Si le résultat de la compilation de cette unité de traduction est liée à une unité de traduction différente contenant des symboles a et foo il ne cassera pas la règle d'une définition, comme dans ce cas particulier unité de traduction a et foo sont private symboles. Cette utilisation a été rendu obsolète par les espaces de noms sans nom.

// test2.cpp
namespace {
   static int a = 1;
   static void foo() {}
}

Lors de la déclaration d'une variable locale dans une fonction, cela signifie que la durée de vie de la variable prolongera du premier appel à la fonction à la fin du programme, et non seulement pour la durée de l'appel:

int foo() {
   static int counter = 0;
   return ++counter;
}
int main() {
  for ( int i = 0; i < 10; ++i ) { 
     std::cout << foo() << std::endl;
  }
}

Dans le code précédent, counter est initialisé une fois quand foo est appelé pour la première fois, mais la variable survivra la fonction et maintenir la valeur entre les différents appels de fonction. Le code précédent imprimera "1 2 3 4 ... 10". Si la variable n'a pas été déclarée static alors la sortie serait "1 1 1 ... 1".

Dans un champ de classe, des moyens de static que le membre est un membre de la classe, et non d'une instance particulière. Cette utilisation est équivalente à l'utilisation dans votre autre question:. L'utilisation de ce membre particulier n'est pas lié à un objet spécifique

struct test {
   int x;
   static int y;
};
int test::y;       // need to define it in one translation unit
int main() {
   // test::x = 5; // !error cannot access a non-static member variable
                   // without an instance
   test::y = 5;    // ok
   test t, other;
   t.x = 10;       // ok
   t.y = 15;       // ok, the standard allows calling a static member through
                   // an instance, but this is the same as test::y
}

Dans ce cas, le x membre est un attribut membre non-statique, et en tant que tel il y a un autre x pour chaque instance de la classe. Dans le programme échantillon t.x et other.x se référer à différents entiers. D'autre part y est static et donc il y a une seule instance de test::y dans le programme. Même si la norme permet d'appeler t.y et other.y les deux utilisations se rapportent à la même variable. La même chose avec les méthodes membres. Si elles sont statiques, ils sont des méthodes de niveau de classe et peuvent être appelés sans exemple, alors que si elles ne sont pas statiques, ils sont appliqués à une instance de béton et la syntaxe a.b ou a->b doivent être utilisés.

Cette utilisation de static est similaire à l'utilisation du même mot clé dans Java, tandis que les deux autres ne sont pas présentes dans cette langue. Il y a une utilisation du mot-clé en Java qui ne figure pas en C ++, et qui est l'utilisation des initialisations statiques de classe (un bloc de code au niveau de la classe entouré de static { ... }). En Java ce bloc de code sera exécuté lorsque la classe est chargée et une seule fois. Initialisation des variables membres statiques en C ++ doit être fait dans le initialiseur de la définition variable.

Answer 1

Le static mot a des significations différentes dans C ++, en fonction du contexte.

Lorsque vous déclarez une fonction libre ou une variable globale, cela signifie que la fonction est de ne pas être disponible en dehors de cette unité de traduction simple:

// test.cpp
static int a = 1;
static void foo() {}

Si le résultat de la compilation de cette unité de traduction est liée à une unité de traduction différente contenant des symboles a et foo il ne cassera pas la règle d'une définition, comme dans ce cas particulier unité de traduction a et foo sont private symboles. Cette utilisation a été rendu obsolète par les espaces de noms sans nom.

// test2.cpp
namespace {
   static int a = 1;
   static void foo() {}
}

Lors de la déclaration d'une variable locale dans une fonction, cela signifie que la durée de vie de la variable prolongera du premier appel à la fonction à la fin du programme, et non seulement pour la durée de l'appel:

int foo() {
   static int counter = 0;
   return ++counter;
}
int main() {
  for ( int i = 0; i < 10; ++i ) { 
     std::cout << foo() << std::endl;
  }
}

Dans le code précédent, counter est initialisé une fois quand foo est appelé pour la première fois, mais la variable survivra la fonction et maintenir la valeur entre les différents appels de fonction. Le code précédent imprimera "1 2 3 4 ... 10". Si la variable n'a pas été déclarée static alors la sortie serait "1 1 1 ... 1".

Dans un champ de classe, des moyens de static que le membre est un membre de la classe, et non d'une instance particulière. Cette utilisation est équivalente à l'utilisation dans votre autre question:. L'utilisation de ce membre particulier n'est pas lié à un objet spécifique

struct test {
   int x;
   static int y;
};
int test::y;       // need to define it in one translation unit
int main() {
   // test::x = 5; // !error cannot access a non-static member variable
                   // without an instance
   test::y = 5;    // ok
   test t, other;
   t.x = 10;       // ok
   t.y = 15;       // ok, the standard allows calling a static member through
                   // an instance, but this is the same as test::y
}

Dans ce cas, le x membre est un attribut membre non-statique, et en tant que tel il y a un autre x pour chaque instance de la classe. Dans le programme échantillon t.x et other.x se référer à différents entiers. D'autre part y est static et donc il y a une seule instance de test::y dans le programme. Même si la norme permet d'appeler t.y et other.y les deux utilisations se rapportent à la même variable. La même chose avec les méthodes membres. Si elles sont statiques, ils sont des méthodes de niveau de classe et peuvent être appelés sans exemple, alors que si elles ne sont pas statiques, ils sont appliqués à une instance de béton et la syntaxe a.b ou a->b doivent être utilisés.

Cette utilisation de static est similaire à l'utilisation du même mot clé dans Java, tandis que les deux autres ne sont pas présentes dans cette langue. Il y a une utilisation du mot-clé en Java qui ne figure pas en C ++, et qui est l'utilisation des initialisations statiques de classe (un bloc de code au niveau de la classe entouré de static { ... }). En Java ce bloc de code sera exécuté lorsque la classe est chargée et une seule fois. Initialisation des variables membres statiques en C ++ doit être fait dans le initialiseur de la définition variable.

Answer 2

Cela signifie que la variable est locale à une unité de traduction (tout simplement, à un seul fichier source), et ne peut être accessible depuis l'extérieur. Cette utilisation de l'électricité statique est en fait dépréciée dans le courant C ++ standard - au lieu que vous êtes censé utiliser les espaces de noms anonymes:

static int x = 0;    

devrait être:

namespace {
    int x = 0;    
}

Answer 3

Ce truc semble être assez bien couvert ici .

Mais pour paraphraser, il y a 2 utilisations dans C

1. Empêcher l'utilisation d'une variable globale en dehors du champ d'application du fichier qui le définit.

2. Autoriser les variables locales au sein d'une fonction de persister accross invocations de la fonction, comme dans

   int getNextId () {   int id = 0 statique;   retourner id ++; }

C ++ hérite de ces deux, et ajoute deux utilisations propres.

1. variables membres statiques: Les variables sont « partagées » accross toutes les instances d'une classe, et peut également être accès sans référence à une instance de la classe. Shared semble que le mauvais mot, mais en substance, je beleive que le résultat est que toute référence à une variable références membres de statique même emplacement mémoire.
2. méthodes statiques. Les méthodes qui peuvent être appelées sans référence à une instance spécifique de la classe qui la définit

Answer 4

statique signifie essentiellement qu'une variable est liée à la durée de vie du programme et non d'une fonction donnée ou instance de classe. Quand devez-vous l'utiliser? Ne pas. Quel est le but? les données de débogage, la plupart du temps.

En général, en C ++, si vous vous trouvez à l'aide des données statiques, vous avez fait mal. Il y a des moments où il est approprié, mais ils sont très rares.

Answer 5

Lorsque statique est utilisé dans une classe en C ++, cela signifie plus ou moins la même chose qu'il fait en Java. Pour les variables, cela signifie que l'une d'une instance de la variable existe pour toutes les classes et fonctions, cela signifie que la fonction n'accède pas implicitement ce pointeur du tout.

En C et C ++ lorsque statique est utilisé pour une variable globale ou d'une fonction, cela signifie que la variable ne peut être référencé dans le courant C ou le dossier C. En d'autres termes, le compilateur ne doit pas générer des symboles de déplacement pour la variable ou la fonction.

Lorsque statique est utilisé à côté d'une variable dans une fonction locale, cela signifie que la variable ne va pas hors de portée, mais conservera sa valeur de fonction appel à la fonction d'appel. La variable devient effectivement une variable globale qui ne peut être accessible à partir de la fonction donnée.

Answer 6

membres de la classe statiques sont des données et des fonctions qui sont associées à la classe elle-même, plutôt que les objets de la classe.

Dans l'exemple suivant, la classe Fred a un x_ membre de données statiques et une y_ instance de membre de données. Il n'y a qu'une seule copie de Fred :: x_ quel que soit le nombre d'objets Fred sont créés (y compris aucun objet Fred), mais il y a une y_ par objet Fred. Ainsi x_ est dit être associée à la classe et y_ est dit être associé à un objet individuel de la classe. De même classe Fred a une fonction membre statique f () et un g () de la fonction de membre de l'instance.

class Fred {
    public:
        static void f() throw();                           <-- 1
        void g() throw();                                  <-- 2
    protected:
        static int x_;                                     <-- 3
        int y_;                                            <-- 4
};

(1) fonction de membre associé à la classe

(2) de la fonction de membre associé à un objet individuel de la classe

(3) élément de données associé à la classe

(4) d'élément de données associé à un objet individuel de la classe

Utilisation:

Lorsque vous voulez garder les voies du nombre d'instances d'une classe que vous avez créé utilisez variable statique. Par exemple, dans une « voiture » classe chaque instance de voiture peut avoir un numéro de série unique (_y dans ce cas) et l'entreprise peut vouloir garder une trace du nombre de voitures produites (_x dans ce cas).