Какое максимальное количество символов может хранить переменная типа char

Тип данных char

Как вы уже знаете, тип данных char используется для хранения отдельных символов. Оказывается, кроме символов, в переменную данного типа можно записать целое число. При этом размер этого типа данных всего 256 значений. В переменной данного типа можно хранить значения от 0 до 255 включительно, либо от -128 до 127 . Это зависит от вашего компилятора.

Сейчас поясню, зачем это нужно. В памяти компьютера всё хранится в виде 0 или 1 , это нам известно. Чтобы хранить числа, компьютер переводит их в двоичную систему счисления. Но как быть с буквами, знаками препинания? Для этого люди придумали специальные таблицы, которые называются кодировками .

В такой таблице каждому символу сопоставляется определённое число. И уже это число преобразуется в двоичную систему и хранится в памяти компьютера. С кодировками часто бывают проблемы. Они возникают из-за того, что одному числу в разных таблицах могут соответствовать разные символы.

Язык Си использует одну из таких таблиц – таблицу ASCII (аббр. American Standard Code for Information Interchange) .

В ней первые числа от 0 до 32 зарезервированы для служебных команд, например, 10 используется для перевода строки.А вот символ с кодом 0 обозначает конец символьной строки. Он нам скоро понадобится.
Вот посмотрите на следующий пример.

А вот результат её работы.

Рис.1 Пример вывода служебного символа на экран

Как видите, символ с кодом 10 , действительно, переводит строку (соответствует escape-последовательности \n ).

Сохрани в закладки или поддержи проект.

Практика

Решите предложенные задачи:

Для удобства работы сразу переходите в полноэкранный режим

Исследовательские задачи для хакеров

Проверить как в вашей системе работает тип char. Для этого можете использовать следующую программу:

Какие значения хранит char

У меня возник вопрос по поводу значений которые может хранить char. Википедия говорит о том, что: Если char определён как signed (знаковый), то его диапазон значений составляет от −128 до 127. И теперь я хочу сделать вывод всех символов, которые может хранить char .

На вывод получаю:

Но если я пишу вот такой код:

Результаты вывода примерно одинаковые, разве что немного отличается порядок, почему так? Но это еще не самое главное: если диапазон значений от -128 до 127 (включительно), то почему тогда я могу записать число 256 для signed char . Объясните мне пожалуйста)

Отрицательные числа в архитектуре IBM PC представляются в так называемом дополнительном коде. Т.е., если мы имеем разрядность n , то некоторое отрицательное число -k в знаковой трактовке (signed) соответствует числу 2^n-k в беззнаковой трактовке (unsigned). Так, для типа char имеем разрядность n==8 . Тогда отрицательное число -k соответствуют беззнаковому 256-k . Например, -1 для signed char — это 256-1 == 255 для unsigned char . А знаковое -128 — это беззнаковое 256-128 == 128 . Таким образом, если мы будем отсчитывать char со знаком от 0 по возрастанию, то получим последовательность: 0, 1, 2. 126, 127 , а после 127 мы получим сразу -128 (это называется знаковым переполнением разрядной сетки), и последовательность продолжится (в скобках укажу беззнаковую трактовку): -127 (129) , -126 (130). -2 (254), -1 (255), 0 .

По-этому перебор всех char от -128 до +127 равносилен перебору всех unsigned char сначала от 128 до 255, а затем от 0 до 127 — это ваш первый цикл, в то время как второй цикл перебирает символы уже в нормальном порядке от 0 до 255.

Значение любого целочисленного типа может быть преобразовано в значение любого другого целочисленного типа. Алгоритм преобразования следующий (conv.integral):

• Если целевой тип bool , то нулевое значение преобразуется в false , а любое ненулевое значение преобразуется в true .
• Если исходный тип bool , то значение false преобразуется в 0 , а значение true преобразуется в 1 .
• В противном случае, результатом будет значение целевого типа, сравнимое по модулю (congruent modulo) 2^N с исходным значением, где N — это ширина (width) целевого типа (в целевом типе такое значение единственно).

Последний пункт говорит, что преобразования из одного целочисленного типа в другой выполняются по правилам модулярной арифметики. В общем-то статья на Википедии довольно подробно описывает её особенности, но если ранее вы с ней не сталкивались, то полагаю, тут не помешает менее формальное объяснение.

Ширина (width) целочисленного типа — это количество битов, используемых для представления значения данным целочисленным типом (включая знаковый бит). Ширина непосредственным образом определяет диапазон значений (range of representable values) представимых некоторым целочисленным типом. Если ширина целочисленного типа равна N , то для беззнакового типа диапазон равен [0; 2^N — 1] , а для знакового типа диапазон равен [-2^(N-1); 2^(N-1) — 1] .

Для того, чтобы понять, каков всё-таки будет конечный результат преобразования, можно рассуждать следующим образом (Представленное объяснение приведено сугубо с целью объяснения модулярной арифметики. Компилятор не обязан действовать буквально так, как описано ниже.):

• Если исходное значение представимо целевым типом, то исходное значение не изменится при преобразовании.
• Если исходное значение больше максимального значения, представимого целевым типом, то из исходного значения следует вычитать величину 2^N ( N — ширина целевого типа) до тех пор, пока оно не станет представимо целевым типом. Получившееся значение и будет результатом преобразования.
• Если исходное значение меньше минимального значения, представимого целевым типом, то к исходному значению следует прибавлять величину 2^N ( N — ширина целевого типа) до тех пор, пока оно не станет представимо целевым типом. Получившееся значение и будет результатом преобразования.

Итак, пусть тип char знаковый, и его ширина равна 8 ( N == 8 ), тогда диапазон его значений [-2^(8-1); 2^(8-1) — 1] == [-128; 127] , и 2^N == 2^8 == 256 . Вот некоторые результаты преобразований в соответствии с описанными правилами:

Если учитывать, что для представления целых числе используется дополнительный код (two’s complement), то алгоритм преобразования можно описать так.

Пусть ширина целевого типа равна N , а ширина исходного типа равна K , тогда

• если N <= K , то тогда младшие N бит исходного значения будут в точности кодировать значение целевого типа.
• если N > K и исходное значение неотрицательно, то дополняем старшие биты исходного значения нулями так, чтобы итоговое количество бит стало равно N . Получившаяся последовательность бит кодирует значение целевого типа.
• если N > K и исходное значение отрицательно, то дополняем старшие биты исходного значения единицами так, чтобы итоговое количество бит стало равно N . Получившаяся последовательность бит кодирует значение целевого типа.

Итак, пусть ширина типа unsigned short равна шестнадцати битам, а типа char равна восьми битам (и он знаковый).

Преобразуем значение 3968 типа unsigned short в значение типа char .

Младшие восемь бит кодируют значение целевого типа:

Преобразуем значение 1 типа char в значение типа unsigned short .

Т.к. исходное значение неотрицательно, то дополняем старшие биты нулями до необходимого размера.

Преобразуем значение -1 типа char в значение типа unsigned short .

Т.к. исходное значение отрицательно, то дополняем старшие биты единицами до необходимого размера.

Написанное выше справедливо начиная с C++20. В более ранних версиях стандарта есть некоторые отличия.

Какое максимальное количество символов может хранить переменная типа char

Каждая переменная имеет определенный тип. И этот тип определяет, какие значения может иметь переменная, какие операции с ней можно производить и сколько байт в памяти она будет занимать. В языке C++ определены следующие базовые типы данных: логический тип bool , целочисленные типы, типа чисел с плавающей точкой, символьные типы. Рассмотрим эти группы по отдельности.

Логический тип

Логический тип bool может хранить одно из двух значений: true (истинно, верно) и false (неверно, ложно). Например, определим пару переменных данного типа и выведем их значения на консоль:

При выводе значения типа bool преобразуются в 1 (если true) и 0 (если false). Как правило, данный тип применяется преимущество в условных выражениях, которые будут далее рассмотрены.

Значение по умолчанию для переменных этого типа — false .

Целочисленные типы

Целые числа в языке C++ представлены следующими типами:

signed char : представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любой значение из диапазона от -128 до 127

unsigned char : представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любой значение из диапазона от 0 до 255

char : представляет один символ в кодировке ASCII. Занимает в памяти 1 байт (8 бит). Может хранить любое значение из диапазона от -128 до 127, либо от 0 до 255

Несмотря на то, что данный тип представляет тот же диапазон значений, что и вышеописанный тип signed char , но они не эквивалентны. Тип char предназначен для хранения числового кода символа и в реальности может представлять как signed byte , так и unsigned byte в зависимости от конкретного компилятора.

short : представляет целое число в диапазоне от –32768 до 32767. Занимает в памяти 2 байта (16 бит).

Данный тип также имеет псевдонимы short int , signed short int , signed short .

unsigned short : представляет целое число в диапазоне от 0 до 65535. Занимает в памяти 2 байта (16 бит).

Данный тип также имеет синоним unsigned short int .

int : представляет целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита). Диапазон предельных значений соответственно также может варьироваться от –32768 до 32767 (при 2 байтах) или от −2 147 483 648 до 2 147 483 647 (при 4 байтах). Но в любом случае размер должен быть больше или равен размеру типа short и меньше или равен размеру типа long

Данный тип имеет псевдонимы signed int и signed .

unsigned int : представляет положительное целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита), и из-за этого диапазон предельных значений может меняться: от 0 до 65535 (для 2 байт), либо от 0 до 4 294 967 295 (для 4 байт).

Имеет псевдоним unsigned

long : в зависимости от архитектуры может занимать 4 или 8 байт и представляет целое число в диапазоне от −2 147 483 648 до 2 147 483 647 (при 4 байтах) или от −9 223 372 036 854 775 808 до +9 223 372 036 854 775 807 (при 8 байтах). Занимает в памяти 4 байта (32 бита) или.

Имеет псевдонимы long int , signed long int и signed long

unsigned long : представляет целое число в диапазоне от 0 до 4 294 967 295. Занимает в памяти 4 байта (32 бита).

Имеет синоним unsigned long int .

long long : представляет целое число в диапазоне от −9 223 372 036 854 775 808 до +9 223 372 036 854 775 807. Занимает в памяти 8 байт (64 бита).

Имеет псевдонимы long long int , signed long long int и signed long long .

unsigned long long : представляет целое число в диапазоне от 0 до 18 446 744 073 709 551 615. Занимает в памяти, как правило, 8 байт (64 бита).

Имеет псевдоним unsigned long long int .

Для представления чисел в С++ применятся целочисленные литералы со знаком или без, типа -10 или 10. Например, определим ряд переменных целочисленных типов и выведем их значения на консоль:

Различные системы исчисления

По умолчанию все стандартные целочисленные литералы представляют числа в привычной нам десятичной системе. Однако C++ также позволяет использовать и числа в других системах исчисления.

Чтобы указать, что число — шестнадцатеричное, перед числом указывается префикс 0x или 0X . Например:

Чтобы указать, что число — восьмеричное, перед числом указывается ноль 0 . Например:

Бинарные литералы предваряются префиксом 0b или 0B :

Все эти типы литералов также поддерживают суффиксы U/L/LL :

Числа с плавающей точкой

Для хранения дробных чисел в C++ применяются числа с плавающей точкой. Число с плавающей точкой состоит из двух частей: мантиссы и показателя степени . Оба могут быть как положительными, так и отрицательными. Величина числа – это мантисса, умноженная на десять в степени экспоненты.

Например, число 365 может быть записано в виде числа с плавающей точкой следующим образом:

В качестве разделителя целой и дробной частей используется символ точки. Мантисса здесь имеет семь десятичных цифр — 3.650000 , показатель степени — две цифры 02 . Буква E означает экспоненту, после нее указывается показатель степени (степени десяти), на которую умножается часть 3.650000 (мантисса), чтобы получить требуемое значение. То есть, чтобы вернуться к обычному десятичному представлению, нужно выполнить следующую операцию:

Другой пример — возьмем небольшое число:

В данном случае мы имеем дело с числом –3.65 × 10 -3 , что равно –0.00365 . Здесь мы видим, что в зависимости от значения показателя степени десятичная точка «плавает». Собственно поэтому их и называют числами с плавающей точкой.

Однако хотя такая запись позволяет определить очень большой диапазон чисел, не все эти числа могут быть представлены с полной точностью; числа с плавающей запятой в целом являются приблизительными представления точного числа. Например, число 1254311179 выглядело бы так: 1.254311E09 . Однако если перейти к десятичной записи, то это будет 1254311000 . А это не то же самое, что и 1254311179 , поскольку мы потеряли три младших разряда.

В языке C++ есть три типа для представления чисел с плавающей точкой:

float : представляет вещественное число одинарной точности с плавающей точкой в диапазоне +/- 3.4E-38 до 3.4E+38. В памяти занимает 4 байта (32 бита)

double : представляет вещественное число двойной точности с плавающей точкой в диапазоне +/- 1.7E-308 до 1.7E+308. В памяти занимает 8 байт (64 бита)

long double : представляет вещественное число двойной точности с плавающей точкой не менее 8 байт (64 бит). В зависимости от размера занимаемой памяти может отличаться диапазон допустимых значений.

В своем внутреннем бинарном представлении каждое число с плавающей запятой состоит из одного бита знака, за которым следует фиксированное количество битов для показателя степени и набор битов для хранения мантиссы. В числах float 1 бит предназначен для хранения знака, 8 бит для экспоненты и 23 для мантиссы, что в сумме дает 32 бита. Мантисса позволяет определить точность числа в виде 7 десятичных знаков.

В числах double : 1 знаковый бит, 11 бит для экспоненты и 52 бит для мантиссы, то есть в сумме 64 бита. 52-разрядная мантисса позволяет определить точность до 16 десятичных знаков.

Для типа long double расклад зависит от конкретного компилятора и реализации этого типа данных. Большинство компиляторов предоставляют точность до 18 — 19 десятичных знаков (64-битная мантисса), в других же (как например, в Microsoft Visual C++) long double аналогичен типу double .

В C++ литералы чисел с плавающими точками представлены дробными числами, которые в качестве разделителя целой и дробной частей применяют точку:

Даже если переменной присваивается целое число, чтобы показать, что мы присваиваем число с плавающей точкой, применяется точка:

Так, здесь число 1. представляет литерал числа с плавающей точкой, и в принципе аналогичен 1.0 .

По умолчанию все такие числа с точкой расцениваются как числа типа double. Чтобы показать, что число представляет другой тип, для float применяется суффикс f / F , а для long double — l / L :

В качестве альтернативы также можно применять экспоненциальную запись:

Размеры типов данных

При перечислении типов данных указывался размер, который он занимает в памяти. Но стандарт языка устанавливает лишь минимальные значения, которые должны быть. Например, для типов int и short минимальное значение — 16 бит, для типа long — 32 бита, для типа long double — 64 разряда. При этом размер типа long должен быть не меньше размера типа int, а размер типа int — не меньше размера типа short, а размер типа long double должен быть не меньше double . А разработчики компиляторов могут выбирать предельные размеры для типов самостоятельно, исходя из аппаратных возможностей компьютера.

К примеру, компилятор g++ Windows для long double использует 16 байт. А компилятор в Visual Studio, который также работает под Windows, и clang++ под Windows для long double используют 8 байт. То есть даже в рамках одной платформы разные компиляторы могут по разному подходить к размерам некоторых типов данных. Но в целом используются те размеры, которые указаны выше при описании типов данных.

Однако бывают ситуации, когда необходимо точно знать размер определенного типа. И для этого в С++ есть оператор sizeof() , который возвращает размер памяти в байтах, которую занимает переменная:

Символьные типы

В C++ есть следующие символьные типы данных:

char : представляет один символ в кодировке ASCII. Занимает в памяти 1 байт (8 бит). Может хранить любое значение из диапазона от -128 до 127, либо от 0 до 255

wchar_t : представляет расширенный символ. На Windows занимает в памяти 2 байта (16 бит), на Linux — 4 байта (32 бита). Может хранить любой значение из диапазона от 0 до 65 535 (при 2 байтах), либо от 0 до 4 294 967 295 (для 4 байт)

char8_t : представляет один символ в кодировке Unicode. Занимает в памяти 1 байт. Может хранить любой значение из диапазона от 0 до 256

char16_t : представляет один символ в кодировке Unicode. Занимает в памяти 2 байта (16 бит). Может хранить любой значение из диапазона от 0 до 65 535

char32_t : представляет один символ в кодировке Unicode. Занимает в памяти 4 байта (32 бита). Может хранить любой значение из диапазона от 0 до 4 294 967 295

Переменная типа char хранит числовой код одного символа и занимает один байт. Стандарт языка С++ не определяет кодировку символов, которая будет использоваться для символов char, поэтому производители компиляторов могут выбирать любую кодировку, но обычно это ASCII.

В качестве значения переменная типа char может принимать один символ в одинарных кавычках, либо числовой код символа:

В данном случае переменные a1 и a2 будут иметь одно и то же значение, так как 65 — это числовой код символа «A» в таблице ASCII. При выводе на консоль с помощью cout по умолчанию отображается символ.

Кроме того, в C++ можно использовать специальные управляющие последовательности, которые предваряются слешем и которые интерпретируются особым образом. Например, «\n» представляет перевод строки, а «\t» — табуляцию.

Однако ASCII обычно подходит для наборов символов языков, которые используют латиницу. Но если необходимо работать с символами для нескольких языков одновременно или с символами языков, отличных от английского, 256-символьных кодов может быть недостаточно. И в этом случае применяется Unicode .

Unicode (Юникод) — это стандарт, который определяет набор символов и их кодовых точек, а также несколько различных кодировок для этих кодовых точек. Наиболее часто используемые кодировки: UTF-8, UTF-16 и UTF-32. Разница между ними заключается в том, как представлена кодовая точка символа; числовое же значение кода для любого символа остается одним и тем же в любой из кодировок. Основные отличия:

UTF-8 представляет символ как последовательность переменной длины от одного до четырех байт. Набор символов ASCII появляется в UTF-8 как однобайтовые коды, которые имеют те же значения кодов, что и в ASCII. UTF-8 на сегодняшний день является самой популярной кодировкой Unicode.

UTF-16 представляет символы как одно или два 16-битных значения.

UTF-32 представляет все символы как 32-битные значения

В C++ есть четыре типа для хранения символов Unicode: wchar_t , char8_t , char16_t и char32_t ( char16_t и char32_t были добавлены в C+11, а char8_t — в C++20).

wchar_t

Тип wchar_t — это основной тип, предназначенный для наборов символов, размер которых выходит за пределы одного байта. Собственно отсюда и его название: wchar_t — wide (широкий) char. происходит от широкого символа, потому что этот символ «шире», чем обычный однобайтовый символ. Значения wchar_t определяются также как и символы char за тем исключением, что они предваряются символов «L»:

Также можно передать код символа

Значение, заключенное в одинарные кавычки, представляет собой шестнадцатеричный код символа. Обратная косая черта указывает на начало управляющей последовательности, а x после обратной косой черты означает, что код шестнадцатеричный.

Стоит учитывать, что для вывода на консоль символов wchar_t следует использовать не std::cout , а поток std::wcout :

При этом поток std::wcout может работать как с char, так и с wchar_t. А поток std::cout для переменной wchar_t вместо символа будет выводить его числовой код.

Проблема с типом wchar_t заключается в том, что его размер сильно зависит от реализации и применяемой кодировки. Кодировка обычно соответствует предпочтительной кодировке целевой платформы. Так, для Windows wchar_t обычно имеет ширину 16 бит и кодируется с помощью UTF-16. Большинство других платформ устанавливают размер в 32 бита, а в качестве кодировки применяют UTF-32. С одной стороны, это позволяет больше соответствовать конкретной платформе. Но с другой стороны, затрудняет написание кода, переносимого на разные платформы. Поэтому в общем случае часто рекомендуется использовать типы char8_t , char16_t и char32_t . Значения этих типов предназначены для хранения символов в кодировке UTF-8, UTF-16 или UTF-32 соответственно, а их размеры одинаковы на всех распространенных платформах.

Для определения символов типов char8_t , char16_t и char32_t применяются соответственно префиксы u8, u и U:

Стоит отметить, что для вывода на консоль значений char8_t/char16_t/char32_t пока нет встроенных инструментов типа std:cout/std:wcout .

Спецификатор auto

Иногда бывает трудно определить тип выражения. В этом случае можно предоставить компилятору самому выводить тип объекта. И для этого применяется спецификатор auto . При этом если мы определяем переменную со спецификатором auto, эта переменная должна быть обязательно инициализирована каким-либо значением:

На основании присвоенного значения компилятор выведет тип переменной. Неинициализированные переменные со спецификатором auto не допускаются:

Типы данных С++

В данном разделе будут рассмотрены основные типы данных в С++, эти типы данных ещё называются встроенными. Язык программирования С++ является расширяемым языком программирования. Понятие расширяемый означает то, что кроме встроенных типов данных, можно создавать свои типы данных. Поэтому в С++ существует огромное количество типов данных. Мы будем изучать только основные из них.

целочисленный (логический) тип данных

целочисленный (символьный) тип данных

целочисленные типы данных

типы данных с плавающей точкой

В таблице 1 представлены основные типы данных в С++. Вся таблица делится на три столбца. В первом столбце указывается зарезервированное слово, которое будет определять, каждое свой, тип данных. Во втором столбце указывается количество байт, которое отводится под переменную с соответствующим типом данных. В третьем столбце показан диапазон допустимых значений. Обратите внимание на то, что в таблице все типы данных расположены от меньшего к большему.

Тип данных bool

Первый в таблице — это тип данных bool — целочисленный тип данных, так как диапазон допустимых значений — целые числа от 0 до 255. Но как Вы уже заметили, в круглых скобочках написано — логический тип данных, и это тоже верно. Так как bool используется исключительно для хранения результатов логических выражений. У логического выражения может быть один из двух результатов true или false . true — если логическое выражение истинно, false — если логическое выражение ложно.

Но так как диапазон допустимых значений типа данных bool от 0 до 255, то необходимо было как-то сопоставить данный диапазон с определёнными в языке программирования логическими константами true и false . Таким образом, константе true эквивалентны все числа от 1 до 255 включительно, тогда как константе false эквивалентно только одно целое число — 0. Рассмотрим программу с использованием типа данных bool .

В строке 9 объявлена переменная типа bool , которая инициализирована значением 25. Теоретически после строки 9 , в переменной boolean должно содержаться число 25, но на самом деле в этой переменной содержится число 1. Как я уже говорил, число 0 — это ложное значение, число 1 — это истинное значение. Суть в том, что в переменной типа bool могут содержаться два значения — 0 (ложь) или 1 (истина). Тогда как под тип данных bool отводится целый байт, а это значит, что переменная типа bool может содержать числа от 0 до 255. Для определения ложного и истинного значений необходимо всего два значения 0 и 1. Возникает вопрос: «Для чего остальные 253 значения?».

Исходя из этой ситуации, договорились использовать числа от 2 до 255 как эквивалент числу 1, то есть истина. Вот именно по этому в переменной boolean содержится число 25 а не 1. В строках 10 -13 объявлен оператор условного выбора if, который передает управление оператору в строке 11, если условие истинно, и оператору в строке 13, если условие ложно. Результат работы программы смотреть на рисунке 1.

Рисунок 1 — Тип данных bool

Тип данных char

Тип данных char — это целочисленный тип данных, который используется для представления символов. То есть, каждому символу соответствует определённое число из диапазона [0;255]. Тип данных char также ещё называют символьным типом данных, так как графическое представление символов в С++ возможно благодаря char . Для представления символов в C++ типу данных char отводится один байт, в одном байте — 8 бит, тогда возведем двойку в степень 8 и получим значение 256 — количество символов, которое можно закодировать. Таким образом, используя тип данных char можно отобразить любой из 256 символов. Все закодированные символы представлены в таблице ASCII.

Рассмотрим программу с использованием типа данных char .

Итак, в строке 9 объявлена переменная с именем symbol , ей присвоено значение символа ‘a’ ( ASCII код ). В строке 10 оператор cout печатает символ, содержащийся в переменной symbol . В строке 11 объявлен строковый массив с именем string , причём размер массива задан неявно. В строковый массив сохранена строка «cppstudio.com» . Обратите внимание на то, что, когда мы сохраняли символ в переменную типа char , то после знака равно мы ставили одинарные кавычки, в которых и записывали символ. При инициализации строкового массива некоторой строкой, после знака равно ставятся двойные кавычки, в которых и записывается некоторая строка. Как и обычный символ, строки выводятся с помощью оператора cout , строка 12 . Результат работы программы показан на рисунке 2.

Рисунок 2 — Тип данных char

Целочисленные типы данных

Целочисленные типы данных используются для представления чисел. В таблице 1 их аж шесть штук: short int , unsigned short int , int , unsigned int , long int , unsigned long int . Все они имеют свой собственный размер занимаемой памяти и диапазоном принимаемых значений. В зависимости от компилятора, размер занимаемой памяти и диапазон принимаемых значений могут изменяться. В таблице 1 все диапазоны принимаемых значений и размеры занимаемой памяти взяты для компилятора MVS2010. Причём все типы данных в таблице 1 расположены в порядке возрастания размера занимаемой памяти и диапазона принимаемых значений. Диапазон принимаемых значений, так или иначе, зависит от размера занимаемой памяти. Соответственно, чем больше размер занимаемой памяти, тем больше диапазон принимаемых значений. Также диапазон принимаемых значений меняется в случае, если тип данных объявляется с приставкой unsigned — без знака. Приставка unsigned говорит о том, что тип данных не может хранить знаковые значения, тогда и диапазон положительных значений увеличивается в два раза, например, типы данных short int и unsigned short int .

Приставки целочисленных типов данных:

short — приставка укорачивает тип данных, к которому применяется, путём уменьшения размера занимаемой памяти;

long — приставка удлиняет тип данных, к которому применяется, путём увеличения размера занимаемой памяти;

unsigned (без знака) — приставка увеличивает диапазон положительных значений в два раза, при этом диапазон отрицательных значений в таком типе данных храниться не может.

Так, что, по сути, мы имеем один целочисленный тип для представления целых чисел — это тип данных int . Благодаря приставкам short , long , unsigned появляется некоторое разнообразие типов данных int , различающихся размером занимаемой памяти и (или) диапазоном принимаемых значений.

Типы данных с плавающей точкой

В С++ существуют два типа данных с плавающей точкой: float и double . Типы данных с плавающей точкой предназначены для хранения чисел с плавающей точкой. Типы данных float и double могут хранить как положительные, так и отрицательные числа с плавающей точкой. У типа данных float размер занимаемой памяти в два раза меньше, чем у типа данных double , а значит и диапазон принимаемых значений тоже меньше. Если тип данных float объявить с приставкой long , то диапазон принимаемых значений станет равен диапазону принимаемых значений типа данных double . В основном, типы данных с плавающей точкой нужны для решения задач с высокой точностью вычислений, например, операции с деньгами.

Итак, мы рассмотрели главные моменты, касающиеся основных типов данных в С++. Осталось только показать, откуда взялись все эти диапазоны принимаемых значений и размеры занимаемой памяти. А для этого разработаем программу, которая будет вычислять основные характеристики всех, выше рассмотренных, типов данных.

Данная программа выложена для того, чтобы Вы смогли просмотреть характеристики типов данных в своей системе. Не стоит разбираться в коде, так как в программе используются управляющие операторы, которые Вам, вероятнее всего, ещё не известны. Для поверхностного ознакомления с кодом программы, ниже поясню некоторые моменты. Оператор sizeof() вычисляет количество байт, отводимое под тип данных или переменную. Функция pow(x,y) возводит значение х в степень y , данная функция доступна из заголовочного файла <cmath> . Манипуляторы fixed и setprecision() доступны из заголовочного файла <iomanip> . Первый манипулятор — fixed , передаёт в поток вывода значения в фиксированной форме. Манипулятор setprecision(n) отображает n знаков после запятой. Максимальное значение некоторого типа данных вычисляется по такой формуле:

Пример работы программы можно увидеть на рисунке 3. В первом столбце показаны основные типы данных в С++, во втором столбце размер памяти, отводимый под каждый тип данных и в третьем столбце — максимальное значение, которое может содержать соответствующий тип данных. Минимальное значение находится аналогично максимальному. В типах данных с приставкой unsigned минимальное значение равно 0.

Рисунок 3 — Типы данных С++

Если, например, переменной типа short int присвоить значение 33000, то произойдет переполнение разрядной сетки, так как максимальное значение в переменной типа short int это 32767. То есть в переменной типа short int сохранится какое-то другое значение, скорее всего будет отрицательным. Раз уж мы затронули тип данных int , стоит отметить, что можно опускать ключевое слово int и писать, например, просто short . Компилятор будет интерпретировать такую запись как short int . Тоже самое относится и к приставкам long и unsigned . Например: