Типы данных

В языке C++ доступны следующие элементарные типы данных:

  • bool — логический тип данных. Может содержать значения true (соответствует числу 1) или false (соответствует числу 0). Пример:
using namespace std;
bool is_int = true;
cout << is_int << endl;       // 1
cout << !is_int << endl;      // 0
cout << boolalpha;
cout << is_int << endl;       // true
cout << !is_int << endl;      // false
// Выводим размер в байтах
cout << sizeof(bool) << endl; // 1

В языке C вместо типа bool используется тип _Bool, а ключевые слова true и false отсутствуют. Вместо них используются числа 1 и 0 соответственно. Любое число, отличное от нуля является Истиной, а число равное нулю — Ложью;

  • char — код символа. Занимает 1 байт. Пример:
char ch = 'w';
// Выводим символ
cout << ch << endl;                   // w
// Выводим код символа
cout << static_cast<int>(ch) << endl; // 119
// Выводим размер в байтах
cout << sizeof(char) << endl;         // 1
// #include <limits.h>
cout << CHAR_MIN << endl;             // -128
cout << CHAR_MAX << endl;             // 127
cout << CHAR_BIT << endl;             // 8
// #include <limits>
char min = numeric_limits<char>::min();
char max = numeric_limits<char>::max();
cout << static_cast<int>(min) << endl;  // -128
cout << static_cast<int>(max) << endl;  // 127
  • wchar_t — двухбайтовый символ. Пример:
wchar_t ch = L'w';
// Выводим символ
wcout << ch << endl;                          // w
// Выводим код символа
wcout << static_cast<unsigned>(ch) << endl;   // 119
// Выводим размер в байтах
wcout << sizeof(wchar_t) << endl;             // 2
// #include <limits>
wchar_t min = numeric_limits<wchar_t>::min();
wchar_t max = numeric_limits<wchar_t>::max();
wcout << static_cast<unsigned>(min) << endl;  // 0
wcout << static_cast<unsigned>(max) << endl;  // 65535
  • char16_t — символ в кодировке UTF-16. Пример:
char16_t ch = u'я';
// Выводим код символа
cout << ch << endl;                           // 1103
// Выводим размер в байтах
cout << sizeof(char16_t) << endl;             // 2
// #include <limits>
char16_t min = numeric_limits<char16_t>::min();
char16_t max = numeric_limits<char16_t>::max();
cout << min << endl;                          // 0
cout << max << endl;                          // 65535
  • char32_t — символ в кодировке UTF-32. Пример:
char32_t ch = U'я';
// Выводим код символа
cout << ch << endl;                           // 1103
// Выводим размер в байтах
cout << sizeof(char32_t) << endl;             // 4
// #include <limits>
char32_t min = numeric_limits<char32_t>::min();
char32_t max = numeric_limits<char32_t>::max();
cout << min << endl;                          // 0
cout << max << endl;                          // 4294967295
  • int — целое число со знаком. Диапазон значений зависит от компилятора. Минимальный диапазон от –32 768 до 32 767. На практике диапазон от –2 147 483 648 до 2 147 483 647 (занимает 4 байта). Пример:
int x = 10;
// Выводим десятичное значение
cout << x << endl;                    // 10
printf("%d\n", x);                    // 10
printf("%i\n", x);                    // 10
// Выводим восьмеричное значение
printf("%o\n", x);                    // 12
// Выводим шестнадцатеричное значение
printf("%x\n", x);                    // a
printf("%X\n", x);                    // A
// Выводим размер в байтах
cout << sizeof(int) << endl;          // 4
// #include <limits.h>
cout << INT_MIN << endl;              // -2147483648
cout << INT_MAX << endl;              // 2147483647
// #include <limits>
int min = numeric_limits<int>::min();
int max = numeric_limits<int>::max();
cout << min << endl;                  // -2147483648
cout << max << endl;                  // 2147483647
  • float — вещественное число. Занимает 4 байта. Пример:
setlocale(LC_ALL, "Russian_Russia.1251");
float x = 10.5432f;
// Выводим значение
cout << x << endl;                    // 10.5432
printf("%f\n", x);                    // 10,543200
printf("%.2f\n", x);                  // 10,54
// Выводим размер в байтах
cout << sizeof(float) << endl;        // 4
// #include <limits>
float min = numeric_limits<float>::min();
float max = numeric_limits<float>::max();
cout << min << endl;                  // 1.17549e-38
cout << max << endl;                  // 3.40282e+38
  • double — вещественное число двойной точности. Занимает 8 байтов. Пример:
setlocale(LC_ALL, "Russian_Russia.1251");
double x = 10.5432;
// Выводим значение
cout << x << endl;                    // 10.5432
printf("%f\n", x);                    // 10,543200
printf("%.2f\n", x);                  // 10,54
// Выводим размер в байтах
cout << sizeof(double) << endl;       // 8
// #include <limits>
double min = numeric_limits<double>::min();
double max = numeric_limits<double>::max();
cout << min << endl;                  // 2.22507e-308
cout << max << endl;                  // 1.79769e+308
  • void — означает отсутствие типа. Используется в основном чтобы указать, что функция не возвращает никакого значения, а также для передачи в функцию данных произвольного типа. Пример объявления функции, которая не возвращает значения и принимает указатель на данные произвольного типа:
void free(void *memory);

Перед элементарным типом данных могут быть указаны следующие модификаторы или их комбинация:

  • signed — указывает, что символьный или целочисленный типы могут содержать отрицательные значения.

Тип signed char может хранить значения от –128 до 127. Пример:

signed char ch = 'w';
// Выводим символ
cout << ch << endl;                   // w
// Выводим код символа
cout << static_cast<int>(ch) << endl; // 119
// Выводим размер в байтах
cout << sizeof(ch) << endl;           // 1
// #include <limits.h>
cout << SCHAR_MIN << endl;            // -128
cout << SCHAR_MAX << endl;            // 127
// #include <limits>
signed char min = numeric_limits<signed char>::min();
signed char max = numeric_limits<signed char>::max();
cout << static_cast<int>(min) << endl;  // -128
cout << static_cast<int>(max) << endl;  // 127

Тип signed int (или просто signed) соответствует типу int. Пример:

signed int x = 10;
signed y = 5;
cout << x << endl;                    // 10
cout << y << endl;                    // 5
// Выводим размер в байтах
cout << sizeof(x) << endl;            // 4
// #include <limits>
signed int min = numeric_limits<signed int>::min();
signed int max = numeric_limits<signed int>::max();
cout << min << endl;                  // -2147483648
cout << max << endl;                  // 2147483647
  • unsigned — указывает, что символьный или целочисленный типы не могут содержать отрицательные значения.

Тип unsigned char может содержать значения от 0 до 255. Пример:

unsigned char ch = 119;
cout << ch << endl;                   // w
// Выводим размер в байтах
cout << sizeof(ch) << endl;           // 1
// #include <limits.h>
cout << UCHAR_MAX << endl;            // 255
// #include <limits>
unsigned char min = numeric_limits<unsigned char>::min();
unsigned char max = numeric_limits<unsigned char>::max();
cout << static_cast<unsigned>(min) << endl;  // 0
cout << static_cast<unsigned>(max) << endl;  // 255

Диапазон значений для типа unsigned int (можно указать просто unsigned) зависит от компилятора. Минимальный диапазон от 0 до 65 535. На практике диапазон от 0 до 4 294 967 295. Пример:

unsigned int x = 10;
unsigned y = 5;
cout << x << endl;                    // 10
cout << y << endl;                    // 5
printf("%u\n", x);                    // 10
// Выводим размер в байтах
cout << sizeof(x) << endl;            // 4
// #include <limits.h>
cout << UINT_MAX << endl;             // 4294967295
// #include <limits>
unsigned int min = numeric_limits<unsigned int>::min();
unsigned int max = numeric_limits<unsigned int>::max();
cout << min << endl;                  // 0
cout << max << endl;                  // 4294967295
  • short — может быть указан перед целочисленным типом. Занимает 2 байта.

Диапазон значений у типов short int (или просто short) и signed short int (или просто signed short) от –32 768 до 32 767. Пример:

short int x = 10;
signed short y = 5;
cout << x << endl;                    // 10
cout << y << endl;                    // 5
// Выводим размер в байтах
cout << sizeof(x) << endl;            // 2
// #include <limits.h>
cout << SHRT_MIN << endl;             // -32768
cout << SHRT_MAX << endl;             // 32767
// #include <limits>
short int min = numeric_limits<short int>::min();
short int max = numeric_limits<short int>::max();
cout << min << endl;                  // -32768
cout << max << endl;                  // 32767

Диапазон значений у типа unsigned short int (или просто unsigned short) от 0 до 65 535. Пример:

unsigned short int x = 10;
unsigned short y = 5;
cout << x << endl;                    // 10
cout << y << endl;                    // 5
// Выводим размер в байтах
cout << sizeof(x) << endl;            // 2
// #include <limits.h>
cout << USHRT_MAX << endl;            // 65535
// #include <limits>
unsigned short min = numeric_limits<unsigned short>::min();
unsigned short max = numeric_limits<unsigned short>::max();
cout << min << endl;                  // 0
cout << max << endl;                  // 65535
  • long — может быть указан перед целочисленным типом и типом double.

Диапазон значений у типов long int (или просто long) и signed long int (или просто signed long) от –2 147 483 648 до 2 147 483 647. Занимает 4 байта. Пример:

long int x = 10L;
signed long y = 5L;
cout << x << endl;                    // 10
cout << y << endl;                    // 5
printf("%ld\n", x);                   // 10
// Выводим размер в байтах
cout << sizeof(x) << endl;            // 4
// #include <limits.h>
cout << LONG_MIN << endl;             // -2147483648
cout << LONG_MAX << endl;             // 2147483647
// #include <limits>
long min = numeric_limits<long>::min();
long max = numeric_limits<long>::max();
cout << min << endl;                  // -2147483648
cout << max << endl;                  // 2147483647

Диапазон значений у типа unsigned long int (или просто unsigned long) от 0 до 4 294 967 295. Пример:

unsigned long int x = 10UL;
unsigned long y = 5UL;
cout << x << endl;                    // 10
cout << y << endl;                    // 5
printf("%lu\n", x);                   // 10
// Выводим размер в байтах
cout << sizeof(x) << endl;            // 4
// #include <limits.h>
cout << ULONG_MAX << endl;            // 4294967295
// #include <limits>
unsigned long min = numeric_limits<unsigned long>::min();
unsigned long max = numeric_limits<unsigned long>::max();
cout << min << endl;                  // 0
cout << max << endl;                  // 4294967295

Ключевое слово long перед целым типом может быть указано дважды. Диапазон значений у типов long long int (или просто long long) и signed long long int (или просто signed long long) от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807. Пример:

long long int x = 10LL;
signed long long y = 5LL;
cout << x << endl;                    // 10
cout << y << endl;                    // 5
printf("%lld\n", x);                  // 10
// Выводим размер в байтах
cout << sizeof(x) << endl;            // 8
// #include <limits.h>
cout << LLONG_MIN << endl;            // -9223372036854775808
cout << LLONG_MAX << endl;            // 9223372036854775807
cout << LONG_LONG_MIN << endl;        // -9223372036854775808
cout << LONG_LONG_MAX << endl;        // 9223372036854775807
// #include <limits>
long long min = numeric_limits<long long>::min();
long long max = numeric_limits<long long>::max();
cout << min << endl;                  // -9223372036854775808
cout << max << endl;                  // 9223372036854775807

Диапазон значений у типа unsigned long long int может быть от 0 до 18 446 744 073 709 551 615. Пример:

unsigned long long int x = 10ULL;
unsigned long long y = 5ULL;
cout << x << endl;                    // 10
cout << y << endl;                    // 5
printf("%llu\n", x);                  // 10
// Выводим размер в байтах
cout << sizeof(x) << endl;            // 8
// #include <limits.h>
cout << ULLONG_MAX << endl;           // 18446744073709551615
cout << ULONG_LONG_MAX << endl;       // 18446744073709551615
// #include <limits>
unsigned long long min =
              numeric_limits<unsigned long long>::min();
unsigned long long max =
              numeric_limits<unsigned long long>::max();
cout << min << endl;                  // 0
cout << max << endl;                  // 18446744073709551615

Ключевое слово long можно указать также перед типом double. Пример:

setlocale(LC_ALL, "Russian_Russia.1251");
long double x = 8e+245L;
cout << x << endl;                    // 8e+245
printf("%Le\n", x);                   // 8,000000e+245
// Выводим размер в байтах
cout << sizeof(x) << endl;
// Значение в проекте Test32: 12
// Значение в проекте Test64: 16
// #include <limits>
long double min = numeric_limits<long double>::min();
long double max = numeric_limits<long double>::max();
cout << min << endl;                  // 3.3621e-4932
cout << max << endl;                  // 1.18973e+4932

При использовании модификаторов тип int подразумевается по умолчанию, поэтому тип int можно не указывать. Пример объявления переменных:

short x;    // Эквивалентно: short int x;
long y;     // Эквивалентно: long int y;
signed z;   // Эквивалентно: signed int z;
unsigned k; // Эквивалентно: unsigned int k;

Если переменная может изменять свое значение извне, то перед модификатором указывается ключевое слово volatile. Это ключевое слово предотвращает проведение оптимизации программы, при котором предполагается, что значение переменной может быть изменено только в программе.

Учебник C++ (MinGW-W64)
Учебник C++ (MinGW-W64) в формате PDF

Помощь сайту

ЮMoney (Yandex-деньги): 410011140483022

ПАО Сбербанк:
Счет: 40817810855006152256
Реквизиты банка:
Наименование: СЕВЕРО-ЗАПАДНЫЙ БАНК ПАО СБЕРБАНК
Корреспондентский счет: 30101810500000000653
БИК: 044030653
КПП: 784243001
ОКПО: 09171401
ОКОНХ: 96130
Скриншот реквизитов