C++
Especificadores de clase de almacenamiento

Introducción

Observaciones

mudable

Un especificador que se puede aplicar a la declaración de un miembro de datos no estático y no de referencia de una clase. Un miembro mutable de una clase no es const incluso cuando el objeto es 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;
}

registro

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

estático

El especificador de clase de almacenamiento static tiene tres significados diferentes.

1. Da enlace interno a una variable o función declarada en el ámbito del espacio de nombres.

   // 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. Declara que una variable tiene una duración de almacenamiento estática (a menos que sea thread_local ). Las variables del ámbito del espacio de nombres son implícitamente estáticas. Una variable local estática se inicializa solo una vez, el primer control de tiempo pasa por su definición y no se destruye cada vez que se sale de su alcance.

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

3. Cuando se aplica a la declaración de un miembro de la clase, declara que ese miembro es un miembro estático .

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

Tenga en cuenta que en el caso de un miembro de datos estáticos de una clase, tanto 2 como 3 se aplican simultáneamente: la palabra clave static convierte al miembro en un miembro de datos estáticos y lo convierte en una variable con una duración de almacenamiento estática.

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

En C ++ 11, el significado de auto cambió completamente, y ya no es un especificador de clase de almacenamiento, sino que se usa para la deducción de tipos .

externo

El especificador de clase de almacenamiento extern puede modificar una declaración de una de las tres formas siguientes, según el contexto:

1. Se puede utilizar para declarar una variable sin definirla. Por lo general, esto se usa en un archivo de encabezado para una variable que se definirá en un archivo de implementación separado.

   // 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. constexpr un enlace externo a una variable en el ámbito del espacio de nombres, incluso si const o constexpr hubieran provocado que tuviera un enlace 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. Redecierra una variable en el ámbito del bloque si se declaró previamente con un enlace. De lo contrario, declara una nueva variable con vinculación, que es un miembro del espacio de nombres envolvente más cercano.

   // 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 función también puede ser declarada extern , pero esto no tiene efecto. Generalmente se usa como una sugerencia para el lector de que una función declarada aquí se define en otra unidad de traducción. Por ejemplo:

 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

En el código anterior, si f se cambiara a extern y g a no extern , no afectaría en absoluto la corrección o la semántica del programa, pero probablemente confundiría al lector del código.