const static int foo = 42;

J'ai vu cela dans un code ici sur StackOverflow et je ne pouvais pas comprendre ce que cela faisait. Ensuite, j'ai vu des réponses confuses sur d'autres forums. Ma meilleure hypothèse est qu'il est utilisé en C pour masquer la constante foodes autres modules. Est-ce correct? Si tel est le cas, pourquoi quelqu'un l'utiliserait-il dans un contexte C ++ où vous pouvez simplement le faire private?

Il a des utilisations en C et C ++.

Comme vous l'avez deviné, la staticpartie limite sa portée à cette unité de compilation . Il prévoit également une initialisation statique. constdit simplement au compilateur de ne laisser personne le modifier. Cette variable est placée dans le segment data ou bss selon l'architecture, et peut être en mémoire marquée en lecture seule.

Tout cela est comment C traite ces variables (ou comment C ++ traite les variables d'espace de noms). En C ++, un membre marqué staticest partagé par toutes les instances d'une classe donnée. Que ce soit privé ou non n'affecte pas le fait qu'une variable est partagée par plusieurs instances. Avoir constdessus vous avertira si du code essaierait de modifier cela.

Si elle était strictement privée, alors chaque instance de la classe aurait sa propre version (malgré l'optimiseur).

Beaucoup de gens ont donné la réponse de base mais personne n'a fait remarquer qu'en C ++, la valeur par constdéfaut était staticau namespaceniveau (et certains ont donné des informations erronées). Consultez la section 3.5.3 de la norme C ++ 98.

Tout d'abord un peu de contexte:

Unité de traduction: un fichier source après que le pré-processeur a inclus (récursivement) tous ses fichiers d'inclusion.

Liaison statique: un symbole n'est disponible que dans son unité de traduction.

Lien externe: un symbole est disponible auprès d'autres unités de traduction.

Au namespaceniveau

Cela inclut l'espace de noms global aka les variables globales .

static const int sci = 0; // sci is explicitly static
const int ci = 1;         // ci is implicitly static
extern const int eci = 2; // eci is explicitly extern
extern int ei = 3;        // ei is explicitly extern
int i = 4;                // i is implicitly extern
static int si = 5;        // si is explicitly static

Au niveau de la fonction

staticsignifie que la valeur est conservée entre les appels de fonction.
La sémantique des staticvariables de fonction est similaire aux variables globales en ce qu'elles résident dans le segment de données du programme (et non dans la pile ou le tas), voir cette question pour plus de détails sur staticla durée de vie des variables.

Au classniveau

staticsignifie que la valeur est partagée entre toutes les instances de la classe et constsignifie qu'elle ne change pas.

Cette ligne de code peut en fait apparaître dans plusieurs contextes différents et bien qu'elle se comporte à peu près de la même manière, il existe de petites différences.

Étendue de l'espace de noms

// foo.h
static const int i = 0;

' i' sera visible dans chaque unité de traduction qui comprend l'en-tête. Cependant, à moins que vous n'utilisiez réellement l'adresse de l'objet (par exemple. ' &i'), Je suis à peu près sûr que le compilateur traitera ' i' simplement comme un type sûr 0. Là où deux autres unités de traduction prennent le « &i», l'adresse sera différente pour chaque unité de traduction.

// foo.cc
static const int i = 0;

' i' a un lien interne et ne peut donc pas être référencé de l'extérieur de cette unité de traduction. Cependant, à moins que vous n'utilisiez son adresse, elle sera très probablement traitée comme un type sécurisé 0.

Il convient de souligner que la déclaration suivante:

const int i1 = 0;

est exactement le même que static const int i = 0. Une variable dans un espace de noms déclaré avec constet non explicitement déclarée avec externest implicitement statique. Si vous pensez à cela, il était l'intention du comité C ++ de permettre aux constvariables d'être déclarées dans les fichiers d'en-tête sans toujours avoir besoin du staticmot - clé pour éviter de casser l'ODR.

Portée de la classe

class A {
public:
  static const int i = 0;
};

Dans l'exemple ci-dessus, la norme spécifie explicitement que « i» n'a pas besoin d'être défini si son adresse n'est pas requise. En d'autres termes, si vous n'utilisez « i» que comme un 0 de type sécurisé, le compilateur ne le définira pas. Une différence entre les versions de classe et d'espace de noms est que l'adresse de « i» (si elle est utilisée dans deux unités de traduction ou plus) sera la même pour le membre de la classe. Lorsque l'adresse est utilisée, vous devez en avoir une définition:

// a.h
class A {
public:
  static const int i = 0;
};

// a.cc
#include "a.h"
const int A::i;            // Definition so that we can take the address

C'est une optimisation de petit espace.

Quand tu dis

const int foo = 42;

Vous ne définissez pas une constante, mais créez une variable en lecture seule. Le compilateur est assez intelligent pour utiliser 42 chaque fois qu'il voit foo, mais il allouera également de l'espace dans la zone de données initialisée pour cela. Ceci est fait parce que, comme défini, foo a un lien externe. Une autre unité de compilation peut dire:

extern const int foo;

Pour accéder à sa valeur. Ce n'est pas une bonne pratique car cette unité de compilation n'a aucune idée de la valeur de foo. Il sait juste que c'est un const int et doit recharger la valeur de la mémoire chaque fois qu'il est utilisé.

Maintenant, en déclarant qu'il est statique:

static const int foo = 42;

Le compilateur peut faire son optimisation habituelle, mais il peut aussi dire "hé, personne en dehors de cette unité de compilation ne peut voir foo et je sais qu'il est toujours 42 donc il n'est pas nécessaire de lui allouer de l'espace".

Je dois également noter qu'en C ++, la meilleure façon d'empêcher les noms de s'échapper de l'unité de compilation actuelle est d'utiliser un espace de noms anonyme:

namespace {
    const int foo = 42; // same as static definition above
}

Il manque un «int». Ça devrait être:

const static int foo = 42;

En C et C ++, il déclare une constante entière avec une portée de fichier local de valeur 42.

Pourquoi 42? Si vous ne savez pas déjà (et il est difficile de croire que vous ne le faites pas), c'est une référence à la réponse à la vie, à l'univers et à tout .

En C ++,

static const int foo = 42;

est la meilleure façon de définir et d'utiliser des constantes. Ie utiliser ceci plutôt que

#define foo 42

parce qu'il ne subvertit pas le système de sécurité de type.

À toutes les bonnes réponses, je veux ajouter un petit détail:

Si vous écrivez des plugins (par exemple des DLL ou des bibliothèques .so à charger par un système de CAO), alors statique est un sauveur de vie qui évite les collisions de noms comme celle-ci:

1. Le système CAO charge un plugin A, qui a un "const int foo = 42;" dedans.
2. Le système charge un plugin B, qui a "const int foo = 23;" dedans.
3. En conséquence, le plugin B utilisera la valeur 42 pour foo, car le chargeur de plugin se rendra compte qu'il existe déjà un "foo" avec un lien externe.

Pire encore: l'étape 3 peut se comporter différemment selon l'optimisation du compilateur, le mécanisme de chargement du plugin, etc.

J'ai eu ce problème une fois avec deux fonctions d'assistance (même nom, comportement différent) dans deux plugins. Les déclarer statiques a résolu le problème.

Selon la spécification C99 / GNU99:

• static

  • est un spécificateur de classe de stockage

  • les objets de portée de niveau fichier ont par défaut une liaison externe

  • les objets de portée de niveau fichier avec spécificateur statique ont une liaison interne

• const

  • est un qualificatif de type (fait partie du type)

  • mot-clé appliqué à l'instance de gauche immédiate - ie

    • MyObj const * myVar; - pointeur non qualifié vers le type d'objet qualifié const

    • MyObj * const myVar; - pointeur qualifié const vers un type d'objet non qualifié

  • Utilisation la plus à gauche - appliquée au type d'objet, pas variable

    • const MyObj * myVar; - pointeur non qualifié vers le type d'objet qualifié const

DONC:

static NSString * const myVar; - pointeur constant vers une chaîne immuable avec liaison interne.

L'absence du staticmot - clé rendra le nom de la variable global et pourrait entraîner des conflits de nom au sein de l'application.

inlineVariables C ++ 17

Si vous avez googlé "C ++ const static", alors c'est très probablement ce que vous voulez vraiment utiliser sont des variables en ligne C ++ 17 .

Cette fonctionnalité impressionnante de C ++ 17 nous permet de:

• utilisez simplement une seule adresse mémoire pour chaque constante
• le stocker en tant que constexpr: Comment déclarer constexpr extern?
• faites-le en une seule ligne à partir d'un en-tête

main.cpp

#include <cassert>

#include "notmain.hpp"

int main() {
    // Both files see the same memory address.
    assert(&notmain_i == notmain_func());
    assert(notmain_i == 42);
}

notmain.hpp

#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP

inline constexpr int notmain_i = 42;

const int* notmain_func();

#endif

notmain.cpp

#include "notmain.hpp"

const int* notmain_func() {
    return &notmain_i;
}

Compilez et exécutez:

g++ -c -o notmain.o -std=c++17 -Wall -Wextra -pedantic notmain.cpp
g++ -c -o main.o -std=c++17 -Wall -Wextra -pedantic main.cpp
g++ -o main -std=c++17 -Wall -Wextra -pedantic main.o notmain.o
./main

GitHub en amont .

Voir aussi: Comment fonctionnent les variables en ligne?

Norme C ++ sur les variables en ligne

La norme C ++ garantit que les adresses seront les mêmes. C ++ 17 N4659 standard draft 10.1.6 "Le spécificateur en ligne":

6 Une fonction ou une variable en ligne avec un lien externe doit avoir la même adresse dans toutes les unités de traduction.

cppreference https://en.cppreference.com/w/cpp/language/inline explique que si ce staticn'est pas donné, alors il a un lien externe.

Implémentation de variables en ligne GCC

On peut observer comment il est implémenté avec:

nm main.o notmain.o

qui contient:

main.o:
                 U _GLOBAL_OFFSET_TABLE_
                 U _Z12notmain_funcv
0000000000000028 r _ZZ4mainE19__PRETTY_FUNCTION__
                 U __assert_fail
0000000000000000 T main
0000000000000000 u notmain_i

notmain.o:
0000000000000000 T _Z12notmain_funcv
0000000000000000 u notmain_i

et man nmdit à propos de u:

"u" Le symbole est un symbole mondial unique. Il s'agit d'une extension GNU de l'ensemble standard de liaisons de symboles ELF. Pour un tel symbole, l'éditeur de liens dynamique s'assurera que dans l'ensemble du processus, il n'y a qu'un seul symbole avec ce nom et ce type en cours d'utilisation.

on voit donc qu'il existe une extension ELF dédiée à cela.

Pré-C ++ 17: extern const

Avant C ++ 17, et en C, nous pouvons obtenir un effet très similaire avec un extern const, ce qui conduira à l'utilisation d'un seul emplacement mémoire.

Les inconvénients inlinesont:

• il n'est pas possible de faire la variable constexpravec cette technique, inlinepermet seulement que: Comment déclarer constexpr extern?
• c'est moins élégant car vous devez déclarer et définir la variable séparément dans l'en-tête et le fichier cpp

main.cpp

#include <cassert>

#include "notmain.hpp"

int main() {
    // Both files see the same memory address.
    assert(&notmain_i == notmain_func());
    assert(notmain_i == 42);
}

notmain.cpp

#include "notmain.hpp"

const int notmain_i = 42;

const int* notmain_func() {
    return &notmain_i;
}

notmain.hpp

#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP

extern const int notmain_i;

const int* notmain_func();

#endif

GitHub en amont .

Alternatives d'en-tête pré-C ++ 17 uniquement

Ce ne sont pas aussi bons que la externsolution, mais ils fonctionnent et n'occupent qu'un seul emplacement mémoire:

Une constexprfonction, car constexprimpliqueinline et inline permet (force) la définition d'apparaître sur chaque unité de traduction :

constexpr int shared_inline_constexpr() { return 42; }

et je parie que tout compilateur décent intégrera l'appel.

Vous pouvez également utiliser une variable statique constou constexprcomme dans:

#include <iostream>

struct MyClass {
    static constexpr int i = 42;
};

int main() {
    std::cout << MyClass::i << std::endl;
    // undefined reference to `MyClass::i'
    //std::cout << &MyClass::i << std::endl;
}

mais vous ne pouvez pas faire des choses comme prendre son adresse, sinon il devient utilisé odr, voir aussi: Définition des membres de données statiques constexpr

C

En C, la situation est la même que C ++ avant C ++ 17, j'ai téléchargé un exemple à l' adresse : Que signifie «statique» en C?

La seule différence est qu'en C ++, cela constimplique staticpour les globaux, mais ce n'est pas le cas en C: C ++ sémantique de `static const` vs` const`

Un moyen de l'intégrer entièrement?

TODO: existe-t-il un moyen d'intégrer complètement la variable, sans utiliser de mémoire du tout?

Tout comme ce que fait le préprocesseur.

Cela nécessiterait en quelque sorte:

• interdire ou détecter si l'adresse de la variable est prise
• ajoutez ces informations aux fichiers objets ELF et laissez LTO l'optimiser

En relation:

• Énumération C ++ 11 avec les membres de la classe et l'optimisation du temps de liaison constexpr

Testé dans Ubuntu 18.10, GCC 8.2.0.

Oui, il masque une variable dans un module des autres modules. En C ++, je l'utilise lorsque je ne veux / n'ai pas besoin de modifier un fichier .h qui déclenchera une reconstruction inutile d'autres fichiers. Aussi, j'ai mis le statique en premier:

static const int foo = 42;

En outre, en fonction de son utilisation, le compilateur n'allouera même pas de stockage pour lui et simplement "en ligne" la valeur où il est utilisé. Sans le statique, le compilateur ne peut pas supposer qu'il n'est pas utilisé ailleurs et ne peut pas en ligne.

C'est une constante globale visible / accessible uniquement dans le module de compilation (fichier .cpp). BTW utilisant statique à cette fin est obsolète. Mieux vaut utiliser un espace de noms anonyme et une énumération:

namespace
{
  enum
  {
     foo = 42
  };
}

Le rendre privé signifierait toujours qu'il apparaît dans l'en-tête. J'ai tendance à utiliser la méthode «la plus faible» qui fonctionne. Voir cet article classique de Scott Meyers: http://www.ddj.com/cpp/184401197 (il s'agit de fonctions, mais peut également être appliqué ici).