C++
Variablendeklarationsschlüsselwörter

algorithm Android C Language C# Language Design patterns Java Language GNU/Linux opencv Python Language Qt
Suche…


const

Einen Typbezeichner; Bei Anwendung auf einen Typ wird die const-qualifizierte Version des Typs erstellt. Weitere Informationen zur Bedeutung von const Sie unter const-Schlüsselwort . 

const int x = 123;
x = 456;    // error
int& r = x; // error

struct S {
    void f();
    void g() const;
};
const S s;
s.f(); // error
s.g(); // OK

decltype

C ++ 11

Gibt den Typ seines Operanden aus, der nicht ausgewertet wird.

  • Wenn der Operand e ein Name ohne zusätzliche Klammern ist, dann ist decltype(e) der deklarierte Typ von e . 

    int x = 42;
std::vector<decltype(x)> v(100, x); // v is a vector<int>

  • Wenn der Operand e ein Klassenmitgliedszugriff ohne zusätzliche Klammern ist, dann ist decltype(e) der deklarierte Typ des Mitglieds, auf das zugegriffen wird. 

    struct S {
    int x = 42;
};
const S s;
decltype(s.x) y; // y has type int, even though s.x is const

  • In allen anderen Fällen liefert decltype(e) sowohl den Typ als auch die Wertkategorie des Ausdrucks e wie folgt:

    • Wenn e ein lWert vom Typ T , dann ist decltype(e) T& .
    • Wenn e ein x-Wert vom Typ T , ist decltype(e) T&& .
    • Wenn e ein Wert vom Typ T , dann ist der Typ decltype(e) T

    Dies schließt den Fall mit äußeren Klammern ein. 

    int f() { return 42; }
int& g() { static int x = 42; return x; }
int x = 42;
decltype(f()) a = f(); // a has type int
decltype(g()) b = g(); // b has type int&
decltype((x)) c = x;   // c has type int&, since x is an lvalue
C ++ 14

Das spezielle Formular decltype(auto) leitet den Typ einer Variablen von ihrem Initialisierer oder den Rückgabetyp einer Funktion aus den return Anweisungen in ihrer Definition ab, wobei sie die decltype von decltype und nicht die von auto . 

const int x = 123;
auto y = x;           // y has type int
decltype(auto) z = x; // z has type const int, the declared type of x

unterzeichnet

Ein Schlüsselwort, das Teil bestimmter Integer-Typnamen ist.

  • Wenn es alleine verwendet wird, ist int impliziert, so dass signed , signed int und int vom gleichen Typ sind.
  • In Kombination mit char ergibt sich der Typ signed char , der sich von char , auch wenn char signiert ist. signed char Zeichen umfasst mindestens -127 bis +127.
  • In Kombination mit short , long oder long long ist es überflüssig, da diese Typen bereits signiert sind.
  • signed kann nicht mit bool , wchar_t , char16_t oder char32_t .

Beispiel: 

signed char celsius_temperature;
std::cin >> celsius_temperature;
if (celsius_temperature < -35) {
    std::cout << "cold day, eh?\n";
}

ohne Vorzeichen

Ein Typbezeichner, der die vorzeichenlose Version eines Integer-Typs anfordert.

  • Wenn es alleine verwendet wird, ist int impliziert, also ist unsigned Typ derselbe Typ wie unsigned int .
  • Der Typ unsigned char unterscheidet sich vom Typ char , auch wenn char unsigniert ist. Es kann ganze Zahlen bis zu 255 enthalten.
  • unsigned kann auch mit short , long oder long long kombiniert werden. Es kann nicht mit bool , wchar_t , char16_t oder char32_t .

Beispiel: 

char invert_case_table[256] = { ..., 'a', 'b', 'c', ..., 'A', 'B', 'C', ... };
char invert_case(char c) {
    unsigned char index = c;
    return invert_case_table[index];
    // note: returning invert_case_table[c] directly does the
    // wrong thing on implementations where char is a signed type
}

flüchtig

Eine Typqualifikation; Bei Anwendung auf einen Typ wird die volatile-qualifizierte Version des Typs erstellt. Flüchtige Qualifikation spielt die gleiche Rolle wie const Qualifikation in dem Typsystem, aber volatile nicht daran hindert , Objekte, verändert; stattdessen zwingt der Compiler alle Zugriffe auf solche Objekte als Nebeneffekte.

Wenn im Beispiel unten, memory_mapped_port nicht flüchtig, so könnte der Compiler die Funktion optimieren , so dass es nur die letzte Schreib führt, was falsch wäre , wenn sizeof(int) ist größer als 1. Die volatile Qualifikation Kräfte , um alles zu behandeln sizeof(int) schreibt als verschiedene Nebenwirkungen und führt sie daher alle (in Reihenfolge) aus. 

extern volatile char memory_mapped_port;
void write_to_device(int x) {
    const char* p = reinterpret_cast<const char*>(&x);
    for (int i = 0; i < sizeof(int); i++) {
        memory_mapped_port = p[i];
    }
}


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow