C++ => Variabele declaratie trefwoorden

const

Een typespecificatie; wanneer toegepast op een type, produceert de const-gekwalificeerde versie van het type. Zie const sleutelwoord voor details over de betekenis van 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

Levert het type operand op, dat niet wordt geëvalueerd.

Als de operand e een naam is zonder extra haakjes, is het decltype(e) het gedeclareerde type e .
```
int x = 42;
std::vector<decltype(x)> v(100, x); // v is a vector<int>
```
Als de operand e is tot een decltype(e) zonder extra haakjes, is decltype(e) het gedeclareerde type van het benaderde lid.
```
struct S {
    int x = 42;
};
const S s;
decltype(s.x) y; // y has type int, even though s.x is const
```
In alle andere gevallen decltype(e) levert het type en de waarde categorie van de expressie e als volgt:
- Als e een waarde van het type T , is het decltype(e) T& .
- Als e een xwaarde van type T , dan is decltype(e) T&& .
- Als e een waarde van het type T , is het decltype(e) T
Dit omvat het geval met vreemde haakjes.
```
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

De speciale vorm decltype(auto) afleidt het type van een variabele uit haar initializer of de return type van een functie uit de return verklaringen in de definitie ervan, met behulp van het type aftrek regels van decltype in plaats van die van de 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

ondertekend

Een trefwoord dat deel uitmaakt van bepaalde integer typenamen.

Wanneer alleen gebruikt, wordt int geïmpliceerd, zodat signed , signed int en int hetzelfde type zijn.
In combinatie met char levert dit het type signed char , dat een ander type is dan char , zelfs als char ook is ondertekend. signed char heeft een bereik dat minimaal -127 tot +127 omvat.
In combinatie met short , long of long long is het overbodig, omdat die typen al zijn ondertekend.
signed kan niet worden gecombineerd met bool , wchar_t , char16_t of char32_t .

Voorbeeld:

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

ongetekend

Een typespecificatie die de niet-ondertekende versie van een geheel getal aanvraagt.

Wanneer alleen gebruikt, wordt int geïmpliceerd, dus unsigned is hetzelfde type als unsigned int .
Het type unsigned char verschilt van het type char , zelfs als char is ondertekend. Het kan gehele getallen tot ten minste 255 bevatten.
unsigned kan ook worden gecombineerd met short , long of long long . Het kan niet worden gecombineerd met bool , wchar_t , char16_t of char32_t .

Voorbeeld:

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
}

vluchtig

Een typeaanduiding; wanneer toegepast op een type, produceert het de vluchtig-gekwalificeerde versie van het type. Vluchtige kwalificatie speelt dezelfde rol als const kwalificatie in het type systeem, maar volatile belet niet dat objecten worden gewijzigd; in plaats daarvan dwingt het de compiler om alle toegangen tot dergelijke objecten als bijwerkingen te behandelen.

In het onderstaande voorbeeld, als memory_mapped_port niet vluchtig was, kon de compiler de functie optimaliseren zodat deze alleen de laatste schrijfactie uitvoert, wat onjuist zou zijn als sizeof(int) groter is dan 1. De volatile kwalificatie dwingt hem om alle sizeof(int) schrijft als verschillende bijwerkingen en voert ze dus allemaal (in volgorde) uit.

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

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow

C++
Variabele declaratie trefwoorden

Zoeken…

const

decltype

ondertekend

ongetekend

vluchtig