C++ => Nyckelord med variabel deklaration

const

En typspecifikation; när den tillämpas på en typ, producerar den const-kvalificerade versionen av typen. Se const nyckelord för information om betydelsen av 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

Ger typ av operand, som inte utvärderas.

Om operand e är ett namn utan ytterligare parenteser, är decltype(e) den deklarerade typen av e .
```
int x = 42;
std::vector<decltype(x)> v(100, x); // v is a vector<int>
```
Om operand e är en klassmedlemstillträde utan några extra parenteser, är decltype(e) den deklarerade typen av medlem som åtkomst till.
```
struct S {
    int x = 42;
};
const S s;
decltype(s.x) y; // y has type int, even though s.x is const
```
I alla andra fall ger decltype(e) både typen och värdekategorin för uttrycket e , enligt följande:
- Om e är en lvalue av typ T , är decltype(e) T& .
- Om e är en xvalue av typ T , är decltype(e) T&& .
- Om e är en uppskattning av typ T , är decltype(e) T
Detta inkluderar fallet med främmande parenteser.
```
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

Den speciella formen decltype(auto) härleder typen av en variabel från dess initierare eller retur typ av funktion från return uttalanden i sin definition, med hjälp av typ avdragsregler för decltype snarare än 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

signerad

Ett nyckelord som är en del av vissa namn på heltalstyp.

När den används ensam antyds int , så att signed , signed int och int är samma typ.
I kombination med char ger du den typ signed char , som är en annan typ än char , även om char är signerad. signed char har ett intervall som inkluderar minst -127 till +127, inklusive.
I kombination med short , long eller long long är det överflödigt eftersom dessa typer redan är signerade.
signed kan inte kombineras med bool , wchar_t , char16_t eller char32_t .

Exempel:

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

osignerad

En typspecifikation som begär den osignerade versionen av en heltalstyp.

När den används ensam antyds int , så unsigned är samma typ som unsigned int .
Typen unsigned char skiljer sig från char , även om char är osignerad. Det kan innehålla heltal upp till minst 255.
unsigned kan också kombineras med short , long eller long long . Det kan inte kombineras med bool , wchar_t , char16_t eller char32_t .

Exempel:

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
}

flyktig

En typkvalificering; när den tillämpas på en typ, producerar den flyktiga kvalificerade versionen av typen. Flyktig kvalifikation spelar samma roll som const kvalificering i typsystemet, men volatile förhindrar inte att objekt kan modifieras; istället tvingar den kompilatorn att behandla alla åtkomst till sådana objekt som biverkningar.

I exemplet nedan, om memory_mapped_port inte var flyktiga, skulle kompilatorn kunna optimera funktionen så att den endast utför den slutliga skrivningen, vilket skulle vara fel om sizeof(int) är större än 1. Den volatile kvalificeringen tvingar den att behandla alla sizeof(int) skriver som olika biverkningar och därmed utföra dem alla (i ordning).

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

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

C++
Nyckelord med variabel deklaration

Sök…

const

decltype

signerad

osignerad

flyktig