usage - static variable c++




Que signifie "statique" en C? (12)

  1. Une variable statique à l'intérieur d'une fonction conserve sa valeur entre les invocations.
  2. Une variable globale statique ou une fonction n'est "vue" que dans le fichier dans lequel elle est déclarée

(1) est le sujet le plus étranger si vous êtes un débutant, alors voici un exemple:

#include <stdio.h>

void foo()
{
    int a = 10;
    static int sa = 10;

    a += 5;
    sa += 5;

    printf("a = %d, sa = %d\n", a, sa);
}


int main()
{
    int i;

    for (i = 0; i < 10; ++i)
        foo();
}

Cela imprime:

a = 15, sa = 15
a = 15, sa = 20
a = 15, sa = 25
a = 15, sa = 30
a = 15, sa = 35
a = 15, sa = 40
a = 15, sa = 45
a = 15, sa = 50
a = 15, sa = 55
a = 15, sa = 60

Cela est utile dans les cas où une fonction doit conserver un état entre les invocations et que vous ne souhaitez pas utiliser de variables globales. Attention cependant, cette fonctionnalité doit être utilisée avec parcimonie - cela rend votre code non-thread-safe et plus difficile à comprendre.

(2) Est largement utilisé comme une fonctionnalité de "contrôle d'accès". Si vous avez un fichier .c implémentant certaines fonctionnalités, il n'expose généralement que quelques fonctions "publiques" aux utilisateurs. Le reste de ses fonctions devrait être rendu static , afin que l'utilisateur ne puisse pas y accéder. C'est l'encapsulation, une bonne pratique.

Citant Wikipedia :

Dans le langage de programmation C, static est utilisé avec les variables globales et les fonctions pour définir leur portée dans le fichier conteneur. Dans les variables locales, static est utilisé pour stocker la variable dans la mémoire allouée statiquement au lieu de la mémoire allouée automatiquement. Bien que le langage ne dicte pas l'implémentation de l'un ou l'autre type de mémoire, la mémoire allouée statiquement est généralement réservée dans le segment de données du programme au moment de la compilation, tandis que la mémoire allouée automatiquement est normalement implémentée comme pile d'appels transitoires.

Voir here et here pour plus de détails.

Et pour répondre à votre deuxième question, ce n'est pas comme en C #.

En C ++, cependant, static est également utilisé pour définir les attributs de classe (partagés entre tous les objets de la même classe) et les méthodes. En C il n'y a pas de classes, donc cette fonctionnalité est hors de propos.

J'ai vu le mot static utilisé à différents endroits dans le code C; est-ce comme une fonction / classe statique en C # (où l'implémentation est partagée entre les objets)?


Ça dépend:

int foo()
{
   static int x;
   return ++x;
}

La fonction retournera 1, 2, 3, etc. --- la variable n'est pas dans la pile.

ac:

static int foo()
{
}

Cela signifie que cette fonction n'a de portée que dans ce fichier. Ainsi, ac et bc peuvent avoir des foo() différents, et foo n'est pas exposé aux objets partagés. Donc, si vous avez défini foo dans ac, vous ne pouvez pas y accéder à partir de bc ou d'autres endroits.

Dans la plupart des bibliothèques C, toutes les fonctions "privées" sont statiques et la plupart des "publiques" ne le sont pas.


En C, statique a deux significations, en fonction de la portée de son utilisation. Dans la portée globale, lorsqu'un objet est déclaré au niveau du fichier, cela signifie que cet objet n'est visible que dans ce fichier.

À tout autre domaine, il déclare un objet qui conservera sa valeur entre les différentes heures où la portée particulière est entrée. Par exemple, si un int est supprimé dans une procédure:

void procedure(void)
{
   static int i = 0;

   i++;
}

la valeur de 'i' est initialisée à zéro lors du premier appel à la procédure, et la valeur est conservée chaque fois que la procédure est appelée. si 'i' était imprimé, il sortirait une séquence de 0, 1, 2, 3, ...


Il est important de noter que les variables statiques dans les fonctions sont initialisées à la première entrée dans cette fonction et persistent même après que leur appel a été terminé; dans le cas de fonctions récursives, la variable statique n'est initialisée qu'une seule fois et persiste également sur tous les appels récursifs et même après l'appel de la fonction.

Si la variable a été créée en dehors d'une fonction, cela signifie que le programmeur est seulement capable d'utiliser la variable dans le fichier source que la variable a été déclarée.


Je déteste répondre à une vieille question, mais je ne pense pas que quiconque ait mentionné comment K & R l'explique dans la section A4.1 de «The C Programming Language».

En bref, le mot statique est utilisé avec deux significations:

  1. Static est l'une des deux classes de stockage (l'autre étant automatique). Un objet statique conserve sa valeur entre les invocations. Les objets déclarés en dehors de tous les blocs sont toujours statiques et ne peuvent pas être rendus automatiques.
  2. Mais, lorsque le mot-clé static (utilisé principalement dans le code comme mot-clé) est utilisé avec une déclaration, il donne à cet objet un lien interne de sorte qu'il ne peut être utilisé que dans cette unité de traduction. Mais si le mot-clé est utilisé dans une fonction, il change la classe de stockage de l'objet (l'objet ne sera visible que dans cette fonction). Le contraire de static est le mot-clé extern , qui donne un lien externe à un objet.

Peter Van Der Linden donne ces deux significations dans "Expert C Programming":

  • À l'intérieur d'une fonction, conserve sa valeur entre les appels.
  • Au niveau de la fonction, visible uniquement dans ce fichier.

Les gens continuent de dire que «statique» en C a deux significations. Je propose une autre façon de le voir qui lui donne une signification unique:

  • Appliquer 'static' à un item force cet item à avoir deux propriétés: (a) Il n'est pas visible en dehors de la portée courante; (b) Il est persistant.

La raison pour laquelle il semble avoir deux significations est que, en C, chaque élément auquel 'static' peut être appliqué a déjà l'une de ces deux propriétés , il semble donc que cet usage particulier n'implique que l'autre.

Par exemple, considérons les variables. Les variables déclarées en dehors des fonctions ont déjà une persistance (dans le segment de données), l'application de 'static' ne peut donc les rendre visibles qu'en dehors de la portée actuelle (unité de compilation). Par contre, les variables déclarées à l'intérieur des fonctions ont déjà une non-visibilité en dehors de la portée (fonction) courante, donc appliquer 'static' ne peut que les rendre persistantes.

Appliquer 'static' aux fonctions revient à l'appliquer aux variables globales - le code est forcément persistant (au moins dans la langue), donc seule la visibilité peut être modifiée.

Remarque: Ces commentaires s'appliquent uniquement à C. En C ++, l'application de «statique» aux méthodes de classe donne vraiment le mot clé une signification différente. De même pour l'extension d'argument de tableau C99.


Les variables statiques ont la propriété de conserver leur valeur même lorsqu'elles sont hors de leur portée, donc les variables statiques conservent leur valeur précédente dans leur portée précédente et ne sont pas initialisées à nouveau dans la nouvelle portée.

1. Une variable static statique reste en mémoire pendant l'exécution du programme. Une variable normale ou automatique est détruite lorsqu'un appel de fonction où la variable a été déclarée est terminé.

Les variables statiques sont allouées en mémoire dans le segment de données, pas dans le segment de pile.

3. Les variables statiques (comme les variables globales) sont initialisées à 0 si elles ne sont pas explicitement initialisées. Par exemple, dans le programme ci-dessous, la valeur de x est imprimée comme 0, alors que la valeur de y est quelque chose d'ordure. Voir ceci pour plus de détails.

#include <stdio.h>

int main()
   {
    static int x;
    int y;
    printf("%d \n %d", x, y);
   }

Notez également que static peut être utilisé de 4 manières différentes.

to create permanent storage for local variables in a function.
to specify internal linkage.
to declare member functions that act like non-member functions.
to create a single copy of a data member.

Si vous déclarez ceci dans un fichier mytest.c:

static int my_variable;

Alors cette variable peut seulement être vue de ce dossier. La variable ne peut être exportée nulle part ailleurs.

Si vous déclarez à l'intérieur d'une fonction, la valeur de la variable conservera sa valeur chaque fois que la fonction est appelée.

Une fonction statique ne peut pas être exportée depuis l'extérieur du fichier. Donc, dans un fichier * .c, vous masquez les fonctions et les variables si vous les déclarez statiques.


Si vous déclarez une variable dans une fonction statique, sa valeur ne sera pas stockée dans la pile des appels de fonction et sera toujours disponible lorsque vous appelez à nouveau la fonction.

Si vous déclarez une variable globale static, sa portée sera limitée au fichier dans lequel vous l'avez déclaré. C'est un peu plus sûr qu'un global régulier qui peut être lu et modifié tout au long de votre programme.


Une variable statique est une variable spéciale que vous pouvez utiliser dans une fonction. Elle enregistre les données entre les appels et ne les supprime pas entre les appels. Par exemple:

void func(){
    static int count; // If you don't declare its value, the value automatically initializes to zero
    printf("%d, ", count);
    count++;
}

void main(){
    while(true){
        func();
    }
}

Le résultat:

0, 1, 2, 3, 4, 5, ...


static signifie différentes choses dans des contextes différents.

  1. Vous pouvez déclarer une variable statique dans une fonction C. Cette variable n'est visible que dans la fonction mais elle se comporte comme une variable globale dans la mesure où elle n'est initialisée qu'une seule fois et conserve sa valeur. Dans cet exemple, chaque fois que vous appelez foo() , un nombre croissant est imprimé. La variable statique est initialisée une seule fois.

    void foo ()
    {
    static int i = 0;
    printf("%d", i); i++
    }
    
  2. Une autre utilisation de static est lorsque vous implémentez une fonction ou une variable globale dans un fichier .c mais que vous ne voulez pas que son symbole soit visible en dehors du .obj généré par le fichier. par exemple

    static void foo() { ... }
    






static