bool

char

unsigned char

signed char

int

unsigned int

short

unsigned short

long

unsigned long

float

double

long double

wchar_t

Язык С++ поддерживает несколько базовых типов данных, которые также называют простыми (иногда арифметическими) типами данных. Эти типы определены в самом языке, и все остальные типы строятся на их основе. В табл. 1 приводятся все простейшие типы данных, определенные в С++.
Следует отметить, что в зависимости от версии компилятора область изменения чисел может меняться. Точные пределы изменения чисел приводятся в файлах заголовков limits.h и float.h.

Следующие замечания поясняют некоторые из особенностей использования типов в С++.

• Строго говоря, signed, unsigned, short и long являются не самостоятельными типами, а модификаторами. Тип int определяется в С++ по умолчанию, таким образом, unsigned int и unsigned - это один и тот же тип, и оба варианта записи являются допустимыми в С++. Аналогичным образом можно записать signed или signed int, short или short int, long или long int.
• По умолчанию все целые типы С++ определяются как signed, за исключением типа char. Таким образом, записи signed int и int определяют один и тот же тип.

В спецификации ANSI область изменения целых чисел определена от -127 до 127. Однако использование дополнительного кода (см. также раздел "Дополнительный формат" в главе "Словарь терминов и понятий") увеличивает эту область на единицу, и минимальное целое число равно -128. Числа в плавающем формате не предоставляют возможности точного задания числа 0. Точность определения нуля зависит от выбранного формата числа. Например, число 1E-50 (единица, деленная на 10 в степени 50) не может быть задано типом float, но может быть определено типом double.
Все базовые типы С++, включая символьный и булев, являются числовыми, так как все они, несмотря на различные форматы, в памяти компьютера представлены двоичными числами.
За исключением float, double и long double, все базовые типы являются целыми, что означает отсутствие у них дробной части. Большинство типов, при отсутствии модификатора unsigned, могут определять как положительные, так и отрицательные числа (см. также раздел "Дополнительный формат" в главе "Словарь терминов и понятий").
Константы любого целого типа могут быть заданы в шестнадцатеричной или восьмеричной системе счисления. Для определения шестнадцатеричной константы используется префикс 0x или 0X. Запись такой константы может содержать цифры от 0 до 9, а также символы шестнадцатеричных цифр A, B, C, D, E, F или a, b, c, d, e, f. Признаком восьмеричной константы является начальный 0. В ее записи допустимы только цифры от 0 до 7. В остальных случаях константа считается представленной в десятичной системе счисления.
Следующие три оператора присваивания задают одно и то же значение:
A=0xFFF; A=07777; A=4095;
Если в записи константы встречается суффикс L или l, компилятор интерпретирует константу как long, то есть размещает ее в 4-байтовом слове. Суффикс U (u) указывает на константу типа unsigned. Разрешается комбинировать оба эти суффикса в любом порядке для задания константы типа unsigned long.

Язык С++ поддерживает два варианта записи констант с плавающей точкой (иногда говорят - с плавающей запятой): с десятичной точкой (.) в качестве разделителя и экспоненциальную форму, в которой используются символы e или E (для указания числа 10 в качестве основания степени), за которым следует показатель степени.
По умолчанию константы с плавающей точкой имеют тип double. При наличии суффикса F (f) константа имеет тип float, L (l) - тип long double.
Следует отметить два преимущества работы с целыми числами:

• операции с ними выполняются быстрее;
• они хранят точные целые значения, что позволяет избежать возможных ошибок при округлении.

Тем не менее типы чисел с плавающей точкой являются более гибкими, и во многих случаях их использование необходимо. Следующий пример демонстрирует получение неправильного результата при неверном выборе типов переменных:
   int a=5, b=2, c;
   c = a/b*b; //с равно 4, а не 5
Несмотря на то что мы сначала делим переменную a на b, а затем умножаем результат деления на то же число b, результат не будет равен делимому, так как при выполнении арифметических операций над целыми числами результатом считается целое число. Ошибки можно было бы избежать, определив тип хотя бы одного из операндов как float.
Рассмотрим теперь каждый из типов более подробно.

Тип данных bool (булев) определяет ровно два значения true и false. Переменные этого типа в основном используются в двух случаях: при определении сложных условий в условных инструкциях и в качестве флагов в инструкциях цикла:

//использование булевой переменной

//в условной инструкции

bool bw1,bw2;

//...

bw1 = (x2-x1)/scalex > 100;

bw2 = x2 < 600;

if ( bw1 && bw2 ) myf1 ();

//использование булевой переменной

//в инструкции цикла

bw1=true;

while (bw1)

{//...

if (x2 < 600) bw1 = false;

//...

}

Обычно в С и С++ значения true и false присваивались переменным целого типа. Сейчас более предпочтительным вариантом является использование булевого типа данных для этих значений. Булевой переменной можно присвоить любое целое значение (компилятор выдаст предупреждение, если при этом не выполнено приведение типов), но любое ненулевое значение при этом автоматически преобразуется в true (1).
Любое целое ненулевое значение рассматривается как true в условных инструкциях и инструкциях цикла. Однако результатом операции сравнения или логической операции может быть только 0 (ноль) или 1 (единица).

В памяти компьютера тип данных char представляется, как и другие целые типы, числом, однако в действительности это число является кодом символа. Преобразование символа в число и обратно происходит автоматически в соответствии с таблицей кодировки символов ASCII, представленной в приложении "Таблица ASCII-кодов". Например, код символа "равно" (=) представляется в памяти компьютера как число 61 и занимает один байт. При его обозначении в качестве простого символа он должен быть заключен в апострофы.
На практике тип char довольно редко используется для хранения отдельных символов и значительно чаще для хранения строк, являющихся массивами символов. Инициализировать массив символов можно строкой, например, показанная ниже строка отводит в памяти компьютера 20 байт и заполняет 6 из них символами, заданными в строке:
   char cstr[20]="строка";
Следующий, 7-й, символ отводится для признака конца строки (\0), который называется нуль-терминатором. Опустим в этом примере длину массива и запишем инструкцию следующим образом:
   char cstr[]="строка";
В этом случае в памяти компьютера будет отведено ровно 7 байт, включая нуль-терминатор, и все они будут инициализированы.
В отличие от одного символа строка заключается в кавычки и занимает в памяти компьютера число байт, равное количеству символов в ней, плюс один для признака конца строки.
Тип char эквивалентен типу signed char или unsigned char в зависимости от соответствующего параметра компилятора.

Для управления выводом строки в ней могут быть использованы управляющие последовательности (управляющие символы), представленные в табл. 2. Наиболее часто используемым среди них является символ новой строки (\n). Обратный слэш (\) в С++ всегда является признаком управляющей последовательности, и в связи с этим обычный символ слэша ('\') должен записываться как "двойной слэш", заключенный в апострофы ('\\').
Код символа может быть непосредственно введен в строку С++. Для этого при записи строки перед шестнадцатеричным кодом должна быть записана последовательность \x. При использовании восьмеричного кода его признаком служит одиночный обратный слэш. Последние две строки табл. 2 демонстрируют возможность непосредственного ввода кода ASCII-символа в строку.

Тип unsigned char используется для беззнаковых значений, находящихся в пределах от 0 до 255, и занимает один байт. Подобно типу char тип unsigned char более характерен для определения массивов, чем отдельных переменных, в частности, может быть полезен для определения буферов, хранящих последовательности двоичных данных, например:
&NBSP;&NBSP;&NBSP;unsigned char buf[1000];
Тип char также подходит для этой цели, но unsigned char предпочтительнее благодаря тому, что все биты этого байта равнозначны, значение числа типа unsigned char изменяется от 0 до 255 и является более удобным для работы с шестнадцатеричными числами от 0x0 (0) до 0xFF (255).

Тип signed char используется для значений, находящихся в пределах от -128 до 127, и занимает один байт. Тип char часто, но не всегда, эквивалентен типу signed char. Подобно типам char и unsigned char тип signed char может задаваться для определения буферов, хранящих последовательности двоичных данных, например:
   signed char buf[1000];
Типы char, unsigned char и signed char во многих случаях ведут себя одинаково. Разница проявляется при присваивании байтового значения более длинному целому полю (см. также раздел "Дополнительный формат" в главе "Словарь терминов и понятий").
В следующем примере одно и то же двоичное значение 11111111 присваивается переменным, которые имеют разный тип данных, что приводит к различным результатам:

signed char sch;

unsigned char uch;

sch = 255; //все биты устанавливаются в 1,

              //число представляется как -1

uch = 255; //все биты устанавливаются в 1,

              //число представляется как 255

short i = sch; //расширяется до 1111111111111111

short j = uch; //расширяется до 0000000011111111

Другое различие заключается в том, что если значение большее 128 и меньшее 255 присваивается типу signed char, то компилятор должен его преобразовать. Возможно, при этом будет выведено предупреждение.

Тип int является наиболее используемым целым типом С и С++. Единственное, что можно сказать определенно, это то, что число типа int не короче числа типа short и не длиннее числа типа long:

int decno=40, octno=050, hexno=0x28;

//все 3 числа принимают одно

//и то же значение, равное 40

int neg=-175;

Этот тип используется для объявления положительных или отрицательных целых чисел. В 16-разрядных системах числа типа int могут принимать значения от -32 768 до 32 767 и занимают 2 байта. В 32-разрядных системах числа этого типа занимают 4 байта и принимают те же значения, что и длинные целые, поэтому существует потенциальная опасность того, что в 32-разрядных системах не возникнет ошибки превышения возможного значения.
В связи с этим, несмотря на то, что тип int является наиболее естественным для процессора и требуется при использовании многих библиотечных функций, программисты стараются не задавать этот тип в сложных и достаточно важных программах.

Тип unsigned int имеет тот же размер, что и тип int: 2 байта в 16-разрядных системах (возможные значения от 0 до 65 535) и 4 байта в 32-разрядных системах (возможные значения те же, что и у unsigned long):

unsigned int decno=40, octno=050,

hexno=0x28;

//переменные decno, octno и hexno равны

Большая часть свойств, описанных для целых чисел со знаком, распространяется на беззнаковые целые - главное их отличие заключается в том, что числа типа unsigned int не могут принимать отрицательные значения. Для переносимости программ оптимальным решением является использование типов unsigned short и unsigned long.
Тип unsigned int рекомендуется для работы с полями бит, так как в этом случае они интерпретируются последовательно и являются равнозначными (см. также раздел "Операции над полями бит" в главе "Основные особенности программирования на С++"):

struct scard

{

unsigned int field1:5;

unsigned int field2:2;

unsigned int field3:6;

}

cards[8];

Для определения константы в виде беззнакового целого можно определять ее в шестнадцатеричном виде или использовать суффикс U:
     unsigned int i = 40000U;

Тип short определяет двухбайтные целые числа, которые могут принимать отрицательные значения. Область изменения от -32 768 до 32 767. Этот тип более предсказуем, чем тип int. По умолчанию компилятор сохраняет все целые константы в виде двухбайтных целых чисел со знаком до тех пор, пока этого объема памяти достаточно для их размещения.

Тип unsigned short является двухбайтным целым, которое не может принимать отрицательные значения. Область изменения от 0 до 65 535.
Для определения константы в виде беззнакового двухбайтного числа можно определять ее в шестнадцатеричном виде или использовать суффикс U:
     unsigned short i = 40000U;
При отсутствии суффикса, независимо от того, как это число представлено в памяти, присваивание выполнится верно:
     unsigned short i = 40000;

Тип long является четырехбайтным целым типом, переменные которого могут принимать отрицательные значения. Область его изменения от -2 147 483 648 до 2 147 483 647. Это самый "большой" стандартный целый тип ANSI C:
     long i=100000, j=-1000000, k=-2;
Для представления константы в виде числа типа long используется суффикс L, в противном случае константа сохраняется в виде числа типа short:
     long i=125L;
Использование суффикса может быть особенно полезно при выполнении арифметических действий над числами. Следующий пример демонстрирует эту особенность:

int a=10000;

long res1, res2;

res1=10*a; //неверный результат!

res2=10L*a; //результат равен 100000

Первая инструкция этого примера не дает верного произведения, так как сначала выполняется умножение двух целых чисел, в результате получается целое число, которое затем присваивается переменной res1. Только в случае, если хотя бы один из операндов является длинным целым, в результате получается длинное целое. (Другим решением проблемы res1 является использование приведения типа переменной a к типу long:
     res1=10*(long)a;)

Тип unsigned long является четырехбайтным целым типом, переменные которого не могут принимать отрицательные значения. Область его изменения от 0 до 4 294 967 295. Отсутствие возможности для хранения отрицательных чисел компенсируется в этом типе увеличением в два раза возможных значений положительных чисел:
     unsigned long a=500L, 4000000000;

Тип float используется для четырехбайтных чисел с плавающей точкой. Область изменения чисел этого типа от -3.4*10⁺³⁸ до -3.4*10^-38 и от 3.4*10^-38 до 3.4*10⁺³⁸, при этом обеспечивается точность не меньше шести десятичных цифр.
Для представления чисел с плавающей точкой используются две формы записи:

• экспоненциальная, в которой запись numEexp означает число num, умноженное на 10 в степени exp (при этом, возможно, записи numEexp и numeexp являются идентичными);
• обычная запись в виде десятичного числа с точкой (которая заменяет привычную для математики запятую).

Для сохранения констант в виде числа с плавающей точкой обычной точности следует использовать суффикс F, в противном случае константы сохраняются в виде чисел двойной точности (компилятор при этом может выдавать предупреждение о возможной потере данных в связи с присваиванием константы двойной точности числу обычной точности):

float f1, f2=37.129F,

f3=1.2e-2F, //f3=0.012

f4=4.5E3F; //f4=4500

Тип double используется для восьмибайтных чисел с плавающей точкой. Область изменения чисел этого типа от -1.7*10⁺³⁰⁸ до -1.7*10^-308 и от 1.7*10^-308 до 1.7*10⁺³⁰⁸, при этом обеспечивается точность 15 десятичных цифр (точность вычисления и область изменения чисел этого типа зависят от версии компилятора, информация о них находится в файлах limits.h и float.h).
Для представления чисел с плавающей точкой используются две формы записи:

• экспоненциальная, в которой запись numEexp означает число num, умноженное на 10 в степени exp (при этом, возможно, записи numEexp и numeexp являются идентичными);
• обычная запись в виде десятичного числа с точкой (которая заменяет привычную для математики запятую).

По умолчанию все константы, не являющиеся целыми числами, сохраняются в виде чисел двойной точности:
     double d1=0.0, d2=1.2e-125, d3=3.7E10;

Единственное, что можно точно сказать о числах, объявленных числами этого типа, - они занимают не меньше места в памяти, чем числа типа double, а следовательно, обеспечивают не меньшую точность. Все остальное зависит от компилятора, поэтому этот тип следует применять только после внимательного изучения возможностей используемого компилятора, особенно в том случае, если необходимо обеспечить переносимость программного продукта.

Тип wchar_t используется для хранения символов, занимающих два байта (например, в стандарте Unicode). В связи с тем, что каждый символ этого типа занимает два байта, для формирования строк из него рекомендуются специальные функции. При отсутствии таких функций придется использовать присваивание для каждого символа:

wchar_t wchstr[10];

wchstr[0]='H';

wchstr[1]='i';

wchstr[2]='!';