C++
Specyfikatory klasy pamięci

Wprowadzenie

Uwagi

zmienny

Specyfikator, który można zastosować do deklaracji niestatycznego, nie referencyjnego elementu danych klasy. Zmienny element klasy nie jest const nawet gdy obiekt jest 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;
}

zarejestrować

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

statyczny

Specyfikator klasy przechowywania static ma trzy różne znaczenia.

1. Daje wewnętrzne powiązanie ze zmienną lub funkcją zadeklarowaną w zakresie przestrzeni nazw.

   // 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. Deklaruje, że zmienna ma statyczny czas przechowywania (chyba że jest to thread_local ). Zmienne zakresu przestrzeni nazw są domyślnie statyczne. Statyczna zmienna lokalna jest inicjowana tylko raz, po raz pierwszy kontrola przechodzi przez swoją definicję i nie jest niszczona przy każdym wyjściu z zakresu.

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

3. Po zastosowaniu do deklaracji członka klasy deklaruje ten element jako element statyczny .

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

Zauważ, że w przypadku statycznego elementu danych klasy, zarówno 2, jak i 3 stosuje się jednocześnie: słowo kluczowe static powoduje, że element staje się elementem danych statycznych i przekształca go w zmienną o statycznym czasie przechowywania.

automatyczny

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

W C ++ 11 auto całkowicie zmieniło znaczenie i nie jest już specyfikatorem klasy pamięci, lecz jest używane do odliczenia typu .

zewnętrzny

Specyfikator klasy pamięci extern może modyfikować deklarację na jeden z trzech poniższych sposobów, w zależności od kontekstu:

1. Można go użyć do zadeklarowania zmiennej bez jej definiowania. Zazwyczaj jest to używane w pliku nagłówkowym dla zmiennej, która zostanie zdefiniowana w osobnym pliku implementacji.

   // 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. Daje zewnętrzne powiązanie ze zmienną w zakresie przestrzeni nazw, nawet jeśli const lub constexpr przeciwnym razie spowodowałoby, że miałoby wewnętrzne powiązanie.

   // 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. Ponownie deklaruje zmienną o zasięgu bloku, jeśli została wcześniej zadeklarowana za pomocą powiązania. W przeciwnym razie deklaruje nową zmienną z powiązaniem, która jest członkiem najbliższej otaczającej przestrzeni nazw.

   // 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
   }
   

Funkcję można również zadeklarować jako extern , ale nie ma to żadnego efektu. Zwykle jest używana jako wskazówka dla czytelnika, że zadeklarowana tutaj funkcja jest zdefiniowana w innej jednostce tłumaczeniowej. Na przykład:

 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

W powyższym kodzie, gdyby f zmieniono na extern i g na non- extern , nie wpłynęłoby to wcale na poprawność lub semantykę programu, ale prawdopodobnie wprowadziłby w błąd czytelnika kodu.