Введение

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

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

Логические переменные (bool) могут принимать одно из двух значений: истина (true) или ложь (false). Логические переменные используются для выражения результатов логических операций. Например:
   Void f (int a, int b)
   {
	   bool b1=a==b;       
   //…
   }
Если a и b имеют одинаковые значения, b1 будет равно true, в противном случае - false. По определению, true имеет значение 1 при преобразовании к целому типу, а false - 0. И наоборот, целые можно неявно преобразовывать в логические значения. При этом ненулевые значения преобразуются в true, а ноль - в false. Например:
   Bool b=7;  // b принимает значение true
   Int i=true;  // i принимает значение 1
В арифметических и логических выражениях логические значения преобразуются в целые (int); арифметические и битовые логические операции операции выполняются над преобразованными величинами. Если результат приводится обратно к логическому типу, 0 преобразуется в false, а ненулевое значение - в true. Указатель можно неявно преобразовывать в bool. Ненулевой указатель принимает значение true, нулевой - false.

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

В переменной типа char может храниться один из символов, имеющихся в наборе символов реализации. Например:
char ch='a'; 
Можно с достаточной степенью уверенности предположить, что набор символов конкретной реализации включает в себя десятичные цифры, 26 букв английского алфавита и некоторые основные знаки пунктуации.

Каждая символьная константа имеет свое числовое значение. Например, значением 'b' в наборе символов ASCII является 98. Приведем пример программы, которая будет выводить целое значение введенного символа.

#include
int main()
{
	char c;
	cin>>c;
	cout<<"значением"<<c<<"является"<<int(c);
}

Символьным литералом (символьной константой) называется символ, заключенный в одиночные кавычки.Например, 'a' или 'O'. Типом символьного литерала является char. Такие символьные литералы в действительности являются символическими константами, обозначающим целые значения символов на компьютере, на котором будет выполнятся программа. Например, если вы запускаете программу на машине, использующей набор ASCII, значением 'O' будет 48. Использование символьных литералов вместо десятичных обозначений делает программы более переносимыми. Несколько символов имеют специальное назначение. Они записываются с помощью символа обратной косой черты \. Например, '\n' является символом перевода строки, а '\t' - горизонтальной табуляцией.


Целые типы

Каждый целый тип может быть представлен в одном из трех видов: "просто" int,signed int и unsigned int. Кроме того, целые могут быть трех размеров: short int, "просто" int и long int. Вместо long int можно писать просто long. Аналогично, short является синонимом для short int, unsigned - для unsigned int и signed - для signed int.

Типы unsigned (без знака) идеально подходят для задач, в которых память интерпретируется как массив битов. Использование unsigned вместо int с целью заработать лишний бит для представления положительных чисел почти всегда оказывается неудачным решением. Использование же объявления unsigned для гарантии того, что целое будет неотрицательным, почти никогда не сработает из-за правил неявного преобразования типов.

В отличие от "просто" char, "просто" int всегда знаковые. Тип signed int (целое со знаком) является более точным синонимом "просто" int.

Целые литералы бывают: десятичные, восьмеричные, шестнадцатиричные и символьные. наиболее часто используются десятичные литералы и выглядят они так, как вы и ожидаете:
0 1 2 3 4 5 6 7 8 9

Литерал, который начинается с нуля и символа "x" (0x), является шестнадцатиричным числом. Литерал, который начинается с нуля, за которым следуют цифры, является восьмеричным числом. Например:
Десятичные: 0 2 63 83
Восьмеричные: 00 02 077 0123
Шестнадцатеричные: 0x0 0x2 0x3f 0x53
Буквы a, b, c, d, e, f, либо их эквмваленты в верхнем регистре, используются для обозначения 10, 11, 12, 13, 14 и 15 соответственно. Восьмеричная и шестнадцатиричная формы наиболее полезны для записи цепочек битов.

Для явной записи литералов без знака (unsigned), можно использовать суффикс U. Аналогично, суффикс L можно использовать для явной записи long-литералов. Например, 3 является константой типа int, 3U - unsigned int и 3L - long int. Если суффикс отсутствует, компилятор присваивает целому литералу подходящий тип, основываясь на его значении и размере целых в данной реализации.


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

Типы с плавающей точкой представляют числа с плавающей точкой. Как и целые, типы с плавающей точкой представлены тремя размерами: float (одинарной точности), double (двойной точности) и long double (расширенной точности).

По умолчанию литералы с плавающей точкой являются константами типа double. Как обычно, компилятор должен вывести предупреждение, если литерал слишком длинен для его правильного представления. Вот несколько примеров литералов с плвающей точкой:

1.23   .23   0.23   1.   1.0   1.2e10   1.23e-15

Обратите внимание, что в записи литералов с плавающей точкой не должно быть пробелов. Например, 65.43 e -21 не является литералом, и будет воспринято, скорее всего, как набор четырех различных литералов (что вызовет синтаксическую ошибку). Если требуется литерал типа float, можно явно определить его с помощью суффикса f (или F):

3.14159265f   2.0f   2.997925F

Приведем графическое представление числа с плавающей точкой:

float:
+/- мантисса +/- степень
1 бит 23 бита 1 бит 7 бит
double:
+/- мантисса +/- степень
1 бит 52 бита 1 бит 10 бит
long double:
+/- мантисса +/- степень
1 бит 64 бита 1 бит 14 бит


Тип void

Синтаксически тип void является фундаментальным типом. Однако, его можно использовать только как часть более сложного типа, так как объектов типа void не существует. Этот тип используется либо для указания на то, что функция не возвращает значения, либо в качестве базового типа для указателей на объекты неизвестного типа. Например:
void x;     //ошибка: не существует объектов типа void
void f();   //функция f не возвращает значения
void *pv;   //указатель на объект неизвестного типа
При объявлении функции вы должны указать тип возвращаемого значения. Логично предположить, что для указания того, что функция не возвращает значение, нужно просто опустить тип. Это, однако сделоло бы синтаксис менее единообразным и противоречило бы правилам языка C. Как следствие, в качестве "псевдотипа возвращаемого результата" используется тип void, указывающий на отсутствие возвращаемого значения.

Размеры

Некоторые свойства фундаментальных типов C++, например размер переменной типа int, зависят от реализации.

Размеры объектов в C++ выражаются в единицах размера char. Таким образом, размер char по определению равен 1. Размер объекта или типа можно получить с помощью оператора sizeof. По поводу размеров фундаментальных типов гарантируется следующее:

1=sizeof(char)<=sizeof(short)<=sizeof(int)<=sizeof(long)
1<=sizeof(bool)<=sizeof(long)
sizeof(char)<=sizeof(wchar_t)<=sizeof(long)
sizeof(float)<=sizeof(double)<=sizeof(long double)
sizeof(N)=sizeof((signed N)=sizeof(unsigned N)
где N может быть char, short int, int или long int. Кроме того, гарантируется, что для представления char используется по меньшей мере 8 бит, для представления short - по меньшей мере 16 бит и для long - по меньшей мере 32 бита. Вот пример программы, определяющей размеры каждого типа:
 // sizeof.cpp
#include<stdio.h>
void main()
{
printf("\n  size of bool    = %d\n",sizeof(bool));
printf("  size of char    = %d\n",sizeof(char));
printf("  size of short   = %d\n",sizeof(short));
printf("  size of int     = %d\n",sizeof(int));
printf("  size of long    = %d\n",sizeof(long));
printf("  size of float   = %d\n",sizeof(float));
printf("  size of double  = %d\n",sizeof(double));
printf("  size of long double=%d\n",sizeof(long double));
}
Что дает на экране:

Если возникнет необходимость, значения, зависящие от конкретной реализации, можно получить из <limits.h>. Например:

 // maxmin.cpp
#include<stdio.h>
#include<limits.h>
void main()
{
printf(" minimum signed   char  value=%d\n",SCHAR_MIN);
printf(" maximum signed   char  value=%d\n",SCHAR_MAX);
printf(" maximum unsigned char  value=%d\n",UCHAR_MAX);

printf(" minimum signed   short value=%d\n",SHRT_MIN);
printf(" maximum signed   short value=%d\n",SHRT_MAX);
printf(" maximum unsigned short value=%d\n",USHRT_MAX);

printf(" minimum signed   int   value=%d\n",INT_MIN);
printf(" maximum signed   int   value=%d\n",INT_MAX);

printf(" minimum signed   long  value=%d\n",LONG_MIN);
printf(" maximum signed   long  value=%d\n",LONG_MAX);
}
Что дает на экране:

В файле <float.h> содержатся предельные значения для чисел с плавающей точкой. Вот пример программы, выводящей эти значения на экран:

 // maxmin2.cpp
#include<stdio.h>
#include<float.h>
void main()
{
printf(" minimum float  value=%e\n",FLT_MIN);
printf(" maximum float  value=%e\n",FLT_MAX);

printf(" minimum double value=%e\n",DBL_MIN);
printf(" maximum double value=%e\n",DBL_MAX);

printf(" minimum long double value=%e\n",LDBL_MIN);
printf(" maximum long double value=%e\n",LDBL_MAX);
}
Что дает на экране:

Заключение

Интегральные типы и типы с плавающей точкой могут иметь различные размеры, предоставляя программисту возможность выбора количества используемой памяти, точности и допустимого диапазона значений. Предполагается, что в компьютере имеются байты для хранения символов, слова для хранения целых чисел и выполнения арифметических операций с ними, нечто, подходящее для операций с плавающей точкой, а также адреса для обращения к этим сущностям. Фундаментальные типы C++ совместно с указателями и массивами предоставляют программисту понятия машинного уровня, но в форме, достаточно независимой от реализации.

В большинстве приложений можно обойтись bool для логических значений, int - для целых, char - для символов и double - для чисел с плавающей точкой. Остальные типы являются вариациями, предназначенными для оптимизации и решения других специальных задач. Ими лучше не пользоваться, пока не возникла острая необходимость. Однако их нужно знать, чтобы читать код на C и C++.


Список использованной литературы:

  1. Б.Страуструп "Язык программирования C++" , 3-е издание, "Издательство БИНОМ", 1999 г.
  2. Б. Страуструп. "Введение в язык Си++", (взято с http://emanual.ru)
Приложения:
  1. sizeof.cpp, maxmin.cpp, maxmin2.cpp - исходные тексты программ
  2. sizeof.exe, maxmin.exe, maxmin.exe - исполняемые файлы
  3. stdio.h - заголовочный файл стандартной библиотеки
  4. limits.h - определяет пределы для значений типов
  5. float.h - определяет пределы для значений типов с плавающей точкой

Содержание