C++
Ключевые слова с переменной переменной

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

Const

Спецификатор типа; когда применяется к типу, выдает версию типа const. См. Ключевое слово const для получения подробной информации о значении 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

Устанавливает тип своего операнда, который не оценивается.

Если операнд e является именем без каких-либо дополнительных круглых скобок, то decltype(e) является объявленным типом e .
```
int x = 42;
std::vector<decltype(x)> v(100, x); // v is a vector<int>
```
Если операндом e является доступ к члену класса без каких-либо дополнительных круглых скобок, тогда decltype(e) является объявленным типом доступного элемента.
```
struct S {
    int x = 42;
};
const S s;
decltype(s.x) y; // y has type int, even though s.x is const
```
Во всех других случаях decltype(e) дает как тип, так и категорию значений выражения e следующим образом:
- Если e является l значением типа T , то decltype(e) есть T& .
- Если e - значение x типа T , то decltype(e) - T&& .
- Если e является prvalue типа T , то decltype(e) есть T
Это включает случай с посторонними скобками.
```
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

Специальная форма decltype(auto) выводит тип переменной из ее инициализатора или возвращаемого типа функции из операторов return в ее определении, используя правила вывода типа decltype а не 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

подписанный

Ключевое слово, которое является частью некоторых имен целых типов.

При использовании в одиночку подразумевается int , так что signed , signed int и int имеют один и тот же тип.
В сочетании с char выдает тип signed char , который отличается от char , даже если char также подписан. signed char имеет диапазон, который включает, по меньшей мере, от -127 до +127 включительно.
В сочетании с short , long или long long , он избыточен, поскольку эти типы уже подписаны.
signed не может быть объединен с bool , wchar_t , char16_t или char32_t .

Пример:

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

неподписанный

Спецификатор типа, который запрашивает неподписанную версию целочисленного типа.

При использовании в одиночку подразумевается int , поэтому unsigned имеет тот же тип, что и unsigned int .
Тип unsigned char отличается от char типа, даже если char без знака. Он может содержать целые числа не менее 255.
unsigned также может сочетаться с short , long или long long . Его нельзя комбинировать с bool , wchar_t , char16_t или char32_t .

Пример:

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
}

летучий

Тип классификатора; когда применяется к типу, создается версия с изменчивой квалификацией. Неустойчивая квалификация играет ту же роль, что и const квалификация в системе типов, но volatile не препятствует модификации объектов; вместо этого он вынуждает компилятор обрабатывать все обращения к таким объектам, как побочные эффекты.

В приведенном ниже примере, если memory_mapped_port не был volatile, компилятор мог оптимизировать функцию так, чтобы она выполняла только окончательную запись, которая была бы неправильной, если sizeof(int) больше 1. volatile квалификация заставляет ее обрабатывать все sizeof(int) записывается как разные побочные эффекты и, следовательно, выполняет все их (в порядке).

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

Лицензировано согласно CC BY-SA 3.0

Не связан с Stack Overflow