C++ => Słowa kluczowe deklaracji zmiennej

const

Specyfikator typu; po zastosowaniu do typu, tworzy stałą wersję typu. Zobacz słowo kluczowe const, aby uzyskać szczegółowe informacje na temat znaczenia const .

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

Daje typ swojego operandu, który nie jest analizowany.

Jeśli operand e jest nazwą bez dodatkowych nawiasów, to decltype(e) jest zadeklarowanym typem e .
```
int x = 42;
std::vector<decltype(x)> v(100, x); // v is a vector<int>
```
Jeśli operand e jest dostępem do klasy bez żadnych dodatkowych nawiasów, to decltype(e) jest zadeklarowanym typem dostępnego elementu.
```
struct S {
    int x = 42;
};
const S s;
decltype(s.x) y; // y has type int, even though s.x is const
```
We wszystkich innych przypadkach decltype(e) daje zarówno typ, jak i kategorię wartości wyrażenia e , jak następuje:
- Jeśli e jest wartością typu T , to decltype(e) to T& .
- Jeśli e jest wartością x typu T , to decltype(e) to T&& .
- Jeśli e jest wartością typu T , to decltype(e) to T
Obejmuje to przypadek z obcymi nawiasami.
```
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

Specjalna forma decltype(auto) dedukuje typ zmiennej z jej inicjalizatora lub typ zwracany przez funkcję z instrukcji return w swojej definicji, używając reguł dedukcji typu dla decltype zamiast reguł 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

podpisany

Słowo kluczowe, które jest częścią niektórych nazw typów całkowitych.

Gdy jest używany samodzielnie, int jest domyślny, więc signed , signed int i int są tego samego typu.
W połączeniu z char , zwraca typ signed char , który jest innym typem niż char , nawet jeśli char jest również podpisany. signed char ma zakres, który obejmuje co najmniej -127 do +127 włącznie.
W połączeniu z short , long lub long long jest zbędny, ponieważ te typy są już podpisane.
signed nie można łączyć z bool , wchar_t , char16_t lub char32_t .

Przykład:

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

niepodpisany

Specyfikator typu, który żąda niepodpisanej wersji typu liczby całkowitej.

W przypadku użycia samego, int jest implikowane, więc unsigned jest tego samego typu, co unsigned int .
Typ unsigned char różni się od typu bez char , nawet jeśli char jest bez znaku. Może pomieścić liczby całkowite do co najmniej 255.
unsigned można również łączyć z short , long lub long long . Nie można go łączyć z bool , wchar_t , char16_t lub char32_t .

Przykład:

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
}

lotny

Kwalifikator typu; po zastosowaniu do typu, tworzy wersję typu spełniającą warunki lotności. Kwalifikacja lotna odgrywa taką samą rolę jak kwalifikacja const w systemie typów, ale volatile nie zapobiega modyfikacji obiektów; zamiast tego zmusza kompilator do traktowania wszystkich dostępów do takich obiektów jako skutków ubocznych.

W poniższym przykładzie, gdyby memory_mapped_port nie był lotny, kompilator mógłby zoptymalizować funkcję, tak aby wykonywał tylko końcowy zapis, co byłoby niepoprawne, gdyby sizeof(int) był większy niż 1. volatile kwalifikacja zmusza ją do traktowania wszystkich sizeof(int) pisze jako różne efekty uboczne i dlatego wykonuje je wszystkie (w kolejności).

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

Licencjonowany na podstawie CC BY-SA 3.0

Nie związany z Stack Overflow

C++
Słowa kluczowe deklaracji zmiennej

Szukaj…

const

decltype

podpisany

niepodpisany

lotny