C++
Specifiers di classe di archiviazione

introduzione

Osservazioni

mutevole

Un identificatore che può essere applicato alla dichiarazione di un membro dati non statico e non di riferimento di una classe. Un membro mutabile di una classe non è const nemmeno quando l'oggetto è const .

class C {
    int x;
    mutable int times_accessed;
  public:
    C(): x(0), times_accessed(0) {
    }
    int get_x() const {
        ++times_accessed; // ok: const member function can modify mutable data member
        return x;
    }
    void set_x(int x) {
        ++times_accessed;
        this->x = x;
    }
};

std::vector<int> my_iota(int start, int count) {
    std::vector<int> result(count);
    std::generate(result.begin(), result.end(),
                  [start]() mutable { return start++; });
    return result;
}

Registrare

register int i = 0;
while (i < 100) {
    f(i);
    int g = i*i;
    i += h(i, g);
}

statico

Lo specificatore della classe di archiviazione static ha tre diversi significati.

1. Fornisce il collegamento interno a una variabile o funzione dichiarata nell'ambito dello spazio dei nomi.

   // internal function; can't be linked to
   static double semiperimeter(double a, double b, double c) {
       return (a + b + c)/2.0;
   }
   // exported to client
   double area(double a, double b, double c) {
       const double s = semiperimeter(a, b, c);
       return sqrt(s*(s-a)*(s-b)*(s-c));
   }
   

2. Dichiara una variabile con durata di memorizzazione statica (a meno che non sia thread_local ). Le variabili nell'ambito dello spazio dei nomi sono implicitamente statiche. Una variabile locale statica viene inizializzata solo una volta, il primo controllo del tempo passa attraverso la sua definizione e non viene distrutta ogni volta che si esce dall'ambito.

   void f() {
       static int count = 0;
       std::cout << "f has been called " << ++count << " times so far\n";
   }
   

3. Quando viene applicato alla dichiarazione di un membro della classe, dichiara che il membro deve essere un membro statico .

   struct S {
       static S* create() {
           return new S;
       }
   };
   int main() {
       S* s = S::create();
   }
   

Si noti che nel caso di un membro di dati statici di una classe, entrambi 2 e 3 si applicano contemporaneamente: la parola chiave static fa sia il membro in un membro di dati statici che lo trasforma in una variabile con durata di archiviazione statica.

auto

void f() {
    auto int x; // equivalent to: int x;
    auto y;     // illegal in C++; legal in C89
}
auto int z;     // illegal: namespace-scope variable cannot be automatic

In C ++ 11, l' auto cambiato completamente il significato e non è più un identificatore della classe di memoria, ma viene invece utilizzato per la deduzione del tipo .

extern

L' extern classe di archiviazione extern può modificare una dichiarazione in uno dei tre modi seguenti, a seconda del contesto:

1. Può essere usato per dichiarare una variabile senza definirla. In genere, questo viene utilizzato in un file di intestazione per una variabile che verrà definita in un file di implementazione separato.

   // global scope
   int x;             // definition; x will be default-initialized
   extern int y;      // declaration; y is defined elsewhere, most likely another TU
   extern int z = 42; // definition; "extern" has no effect here (compiler may warn)
   

2. Fornisce il collegamento esterno a una variabile in ambito namespace anche se const o constexpr avrebbero altrimenti causato un collegamento interno.

   // global scope
   const int w = 42;            // internal linkage in C++; external linkage in C
   static const int x = 42;     // internal linkage in both C++ and C
   extern const int y = 42;     // external linkage in both C++ and C
   namespace {
       extern const int z = 42; // however, this has internal linkage since
                                // it's in an unnamed namespace
   }
   

3. Ricalcola una variabile a livello di blocco se precedentemente dichiarata con linkage. Altrimenti, dichiara una nuova variabile con linkage, che è un membro del più vicino spazio dei nomi.

   // global scope
   namespace {
       int x = 1;
       struct C {
           int x = 2;
           void f() {
               extern int x;           // redeclares namespace-scope x
               std::cout << x << '\n'; // therefore, this prints 1, not 2
           }
       };
   }
   void g() {
       extern int y; // y has external linkage; refers to global y defined elsewhere
   }
   

Una funzione può anche essere dichiarata extern , ma ciò non ha alcun effetto. Solitamente viene usato come suggerimento per il lettore che una funzione dichiarata qui è definita in un'altra unità di traduzione. Per esempio:

 void f();        // typically a forward declaration; f defined later in this TU
 extern void g(); // typically not a forward declaration; g defined in another TU

Nel codice precedente, se f stato cambiato in extern e g in non- extern , non influenzerebbe affatto la correttezza o la semantica del programma, ma probabilmente confonderebbe il lettore del codice.