В книге содержится обширный справочный материал по основным элементам языка, включающий в себя наиболее употребительные функции, операторы, директивы и классы, являющиеся ядром языка С++, не зависящим от аппаратной платформы или версии языка. Последовательно и подробно изложен процесс создания программ. Обзор способов решения различных задач представляется в виде сравнения возможностей двух языков — С и С++. Такая насыщенность информацией делает книгу полезной не только начинающим программистам, но и пользователям, активно работающим с С и С++.
Содержание
Введение
С и С++
Объекты
Инкапсуляция
Полиморфизм
Подход к типам в С++
Структура книги
Кому адресована эта книга
Принятые обозначения
От издательства
Часть I. Справочник по основным элементам C++
Словарь терминов и понятий
Абстрактные типы данных
Абстрактный класс
Абстракция данных
Агрегаты
Анонимные объединения
Аргумент
Ассоциативность
Базовый класс
Беззнаковые типы данных
Безопасная сборка программы с учетом типов
Битовое поле
Булевы значения
Виртуальная функция
Вложенные управляющие структуры и вложенные классы
Встраиваемая функция
Выражение
Главная функция
Данные-члены
Декорирование
Деструктор
Директива
Директива препроцессора
Дополнительный формат
Знакорасширение
Значения аргументов по умолчанию
Идентификатор
Именующее выражение
Инкапсуляция
Инструкция
Информация о типах во время выполнения программы
Исключение
Исполняемая инструкция
Класс
Класс памяти
Ключевое слово
Комментарии
Константа
Конструктор
Конструктор базового класса
Конструктор копирования
Конструктор по умолчанию
Косвенность
Литерал
Логические и битовые операторы
Макрос
Массив
Метка
Множественное наследование
Надкласс
Наследование
Область действия
Объект
Объектная ориентация
Объектно-ориентированное программирование
Объявление
Операнд
Оператор
Операторы присваивания
Определение
Параметр
Перегрузка операторов
Перегрузка функций
Переменная
Перечисление
Подкласс
Полиморфизм
Прагма
Приведение типа
Приоритет
Продвижение
Производный класс
Простейшие типы данных
Пространство имен
Прототип
Прототип функции
Пустая инструкция
Разыменование
Реализация
Рекурсия
Сигнатура
Символ новой строки
Сложные типы данных
Создание экземпляров класса
Составные инструкции
Ссылка
Ссылка вперед
Строка
Строковый литерал
Текстовая строка
Указатель
Указатель на функцию
Управляющая последовательность
Управляющая структура
Условная компиляция
Файлы заголовков
Функции
Функции обратного вызова
Функции преобразования
Функция-член
Чистая виртуальная функция
Член
Шаблон
Экземпляр
Экземпляр класса
Типы данных
bool
char
unsigned char
signed char
int
unsigned int
short
unsigned short
long
unsigned long
float
double
long double
wchar_t
Операторы
Ключевые слова - операторы
Оператор sizeof
Оператор new
Оператор delete
Оператор typeid
Операторы присваивания
Поразрядные операторы
Оператор запятая
Декремент
Инкремент
Условный оператор
Логические операторы
Оператор деления по модулю
Операторы-указатели
Операторы-указатели на член объекта
Операторы отношения
Оператор определения области видимости
Операторы приведения типов
Оператор приведения типа старого стиля
Удаление модификатора const
Проверка типа во время выполнения программы
Приведение типа указателя
Преобразование типа между родственными объектами или указателями
Ключевые слова
asm
auto
break
case
catch
class
const
continue
default
do
else
enum
explicit
extern
for
friend
goto
if
inline
main
mutable
namespace
operator
private
protected
public
register
return
static
struct
switch
template
this
throw
try
typedef
union
using
virtual
void
volatile
while
Директивы, макросы и операторы препроцессора
Директивы
#define
#elif
#else
#endif
#error
#if
#ifdef
#ifndef
#include
#line
#pragma
#undef
Предопределенные макросы
__cplusplus
__DATE__
__FILE__
__LINE__
__TIME__
Операторы препроцессора
Библиотечные функции
Обзор библиотечных функций
Поддержка списков параметров переменной длины
Функции консольного ввода/вывода
Обзор
Чтение символов с клавиатуры
Чтение чисел с клавиатуры
Вывод символов на экран
Сравнение консольного и файлового ввода/вывода
Функции проверки категории символов
Функции работы с блоками памяти
Функции работы с датой и временем
Обзор
Использование структуры tm
Сложное формирование даты/времени
Функции работы со строками
Функции файлового ввода/вывода
Обзор
Чтение и запись текстовых файлов
Чтение и запись двоичных файлов
Сводный список функций
Объекты и классы библиотеки ввода/вывода
Краткий обзор библиотеки классов ввода/вывода
Организация ввода/вывода с помощью классов
Расширение оператора вывода
Расширение оператора ввода
Манипуляторы ввода/вывода
Флаги форматирования
Классы нового стиля
Обзор объектов и классов ввода/вывода C++
cerr
cin
clog
cout
fstream
ifstream
istream
istrstream
ofstream
ostream
ostrstream
strstream
Часть II. Краткий курс программирования на C++
Основные особенности программирования на С++
Первая программа на С++
Объявление переменных
Директива #include
Ввод данных
Операции, выражения и комментарии
Функции
Локальные, глобальные и другие переменные
Управляющие инструкции
Особые операции С++
Логические операции и операции над битами
Операции над полями бит
Указатели, массивы и строки
Указатели и передача данных
Передача данных по ссылке
Одномерные массивы
Многомерные массивы и их размещение в памяти компьютера
Инициализация массивов
Массивы и указатели
Строки
Указатели и динамическое распределение памяти
Использование стандартных функций malloc и free
Использование операторов new и delete
Ввод и вывод
Понятие потока
Операторы потоков для ввода/вывода
Управление форматом при работе с потоками
Ввод/вывод строк с помощью библиотеки stdio.h
Функции для работы с файлами в библиотеке stdio.h
Операторы потоков для работы с файлами
Операторы или функции?
Классы
Создание нового класса
Поведение класса
Объекты класса
Указатели на объекты
Достоинства классов
Конструкторы и деструкторы: рождение и смерть объектов
Определение встраиваемой функции
Структура как разновидность класса
Конструкторы
Перегрузка конструкторов
Конструктор по умолчанию
Конструктор копирования
Ссылки и конструктор копирования
Защита параметра от изменений
Примеры конструкторов
Вызов конструкторов и конверсия
Перегрузка операторов
Базовый синтаксис
Создание функций оператора сложения
Для чего нужны функции-друзья
Создание функции оператора присваивания
Указатель this и его использование при создании функций
Создание функции преобразования
Обобщение класса MyStr
Еще один пример перегрузки операторов
Обобщение определения операторов
Имя функции оператора
Бинарные операторы
Унарные операторы
Оператор присваивания
Присваивание переменных разных типов
Специальные операторы присваивания
Операторы инкремента и декремента
Оператор выделения элемента массива
Операторы new и delete
Оператор вызова функции
Ограничения на перегрузку операторов
Наследование
Дилемма программного обеспечения
Создание производного класса
Иерархия наследования
Создание класса без наследования
Наследование и оболочка объекта
Виды доступа: public, private и protected
Пример создания класса
Конструкторы базовых классов
Базовые классы и указатели
Виртуальные функции
Применение ключевого слова virtual
Программирование команд меню
Достоинства виртуальных функций
Чистые виртуальные функции и абстрактные классы
Определение виртуальной функции
Механизм вызова виртуальных функций
Часть III. Приложения
Отличия С и С++
Особенности ANSI C++
Новый стиль файлов заголовков
Операторы приведения типов ANSI
Шаблоны и обработка исключений
Новые ключевые слова
Область видимости в условной инструкции if
Перегрузка функций с перечисляемыми типами
Ссылки вперед для вложенных классов
Стандартные исключения
Таблица ASCII-кодов
Список характерных задач в С++
Алфавитный указатель
ОТРЫВОК
Типы данных
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.
Таблица 1. Простейшие типы данных С++
Тип Описание Область изменения
bool Булево (логическое) значение true или false
char 1-байтовое целое, используемое для хранения символа От -128 до 127 или от 0 до 255
unsigned char 1-байтовое беззнаковое целое От 0 до 255
signed char 1-байтовое целое От -128 до 127
int Целое (2 или 4 байта) short или long
unsigned int Беззнаковое целое От 0 до 65 535
short 2-байтовое целое От -32 768 до 32 767
unsigned short 2-байтовое беззнаковое целое От 0 до 65 535
long 4-байтовое целое От -2 147 483 648 до 2 147 483 647
unsigned long 4-байтовое беззнаковое целое От 0 до 4 294 967 295
float Действительное число (4 байта) От -3.4*10+38 до -3.4*10-38 и от 3.4*10-38 до 3.4*10+38; точность - 7 десятичных цифр
double Действительное число с двойной точностью (8 байт) От -1.7*10+308 до -1.7*10-308 и от 1.7*10-308 до 1.7*10+308; точность - 15 десятичных цифр
long double Длинное действительное число с двойной точностью (10 байт) От -3.4*10+4932 до -3.4*10-4932 и от 3.4*10-4932 до 3.4*10+4932; точность - 19 десятичных цифр
wchar_t 2-байтовый символ, используемый в международной кодировке, такой как Unicode От 0 до 65 535
Следующие замечания поясняют некоторые из особенностей использования типов в С++.
Строго говоря, 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.
ВНИМАНИЕ Константы типа int и long имеют разное представление в памяти компьютера: первые занимают два байта, вторые - четыре байта. Будьте особенно внимательны при задании функций, имеющих параметры типа long, не забывайте указывать суффикс L при их записи.
Язык С++ поддерживает два варианта записи констант с плавающей точкой (иногда говорят - с плавающей запятой): с десятичной точкой (.) в качестве разделителя и экспоненциальную форму, в которой используются символы 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
Тип данных 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
В памяти компьютера тип данных char представляется, как и другие целые типы, числом, однако в действительности это число является кодом символа. Преобразование символа в число и обратно происходит автоматически в соответствии с таблицей кодировки символов ASCII, представленной в приложении "Таблица ASCII-кодов". Например, код символа "равно" (=) представляется в памяти компьютера как число 61 и занимает один байт. При его обозначении в качестве простого символа он должен быть заключен в апострофы.
На практике тип char довольно редко используется для хранения отдельных символов и значительно чаще для хранения строк, являющихся массивами символов. Инициализировать массив символов можно строкой, например, показанная ниже строка отводит в памяти компьютера 20 байт и заполняет 6 из них символами, заданными в строке:
char cstr[20]="строка";
Следующий, 7-й, символ отводится для признака конца строки (\0), который называется нуль-терминатором. Опустим в этом примере длину массива и запишем инструкцию следующим образом:
char cstr[]="строка";
В этом случае в памяти компьютера будет отведено ровно 7 байт, включая нуль-терминатор, и все они будут инициализированы.
В отличие от одного символа строка заключается в кавычки и занимает в памяти компьютера число байт, равное количеству символов в ней, плюс один для признака конца строки.
Тип char эквивалентен типу signed char или unsigned char в зависимости от соответствующего параметра компилятора.
ВНИМАНИЕ При работе со строками переменной длины следует внимательно следить за их длиной, так как автоматического контроля за переполнением массива, отведенного для строки, не производится. Таким образом, копирование строки в слишком короткий массив, отведенный для нее, может привести к порче данных в памяти. ПРИМЕЧАНИЕ Некоторые кодировки символов, например Unicode, требуют для каждого символа два байта. Требованиям таких кодовых таблиц удовлетворяет тип wchar_t.
Для управления выводом строки в ней могут быть использованы управляющие последовательности (управляющие символы), представленные в табл. 2. Наиболее часто используемым среди них является символ новой строки (\n). Обратный слэш (\) в С++ всегда является признаком управляющей последовательности, и в связи с этим обычный символ слэша ('\') должен записываться как "двойной слэш", заключенный в апострофы ('\\').
Код символа может быть непосредственно введен в строку С++. Для этого при записи строки перед шестнадцатеричным кодом должна быть записана последовательность \x. При использовании восьмеричного кода его признаком служит одиночный обратный слэш. Последние две строки табл. 2 демонстрируют возможность непосредственного ввода кода ASCII-символа в строку.
Таблица 2. Управляющие последовательности С++
Символ Значение
\a Звонок
\b Удаление предыдущего символа
\f Перевод формата
\n Новая строка
\r Возврат каретки
\t Табуляция
\v Вертикальная табуляция
\' Апостроф
\" Кавычки
\\ Символ "обратный слэш"
\0 Нуль-терминатор (0)
\ddd ASCII-код в 8-ричной системе счисления (здесь d -цифра от 0 до 7)
\xdd ASCII-код в 16-ричной системе счисления (здесь d -цифра от 0 до 9 или буква от A до F)
unsigned char
Тип 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
Тип 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 является наиболее используемым целым типом С и С++. Единственное, что можно сказать определенно, это то, что число типа 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
Тип 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
Тип short определяет двухбайтные целые числа, которые могут принимать отрицательные значения. Область изменения от -32 768 до 32 767. Этот тип более предсказуем, чем тип int. По умолчанию компилятор сохраняет все целые константы в виде двухбайтных целых чисел со знаком до тех пор, пока этого объема памяти достаточно для их размещения.
unsigned short
Тип unsigned short является двухбайтным целым, которое не может принимать отрицательные значения. Область изменения от 0 до 65 535.
Для определения константы в виде беззнакового двухбайтного числа можно определять ее в шестнадцатеричном виде или использовать суффикс U:
unsigned short i = 40000U;
При отсутствии суффикса, независимо от того, как это число представлено в памяти, присваивание выполнится верно:
unsigned short i = 40000;
long
Тип 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
Тип unsigned long является четырехбайтным целым типом, переменные которого не могут принимать отрицательные значения. Область его изменения от 0 до 4 294 967 295. Отсутствие возможности для хранения отрицательных чисел компенсируется в этом типе увеличением в два раза возможных значений положительных чисел:
unsigned long a=500L, 4000000000;
float
Тип float используется для четырехбайтных чисел с плавающей точкой. Область изменения чисел этого типа от -3.4*10+38 до -3.4*10-38 и от 3.4*10-38 до 3.4*10+38, при этом обеспечивается точность не меньше шести десятичных цифр.
Для представления чисел с плавающей точкой используются две формы записи:
экспоненциальная, в которой запись 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, так как это позволяет обеспечить большую точность вычисления. Числа типа float чаще применяются для определения больших массивов и для сохранения информации на диске, то есть там, где критичным является объем памяти, занимаемой данными.
double
Тип double используется для восьмибайтных чисел с плавающей точкой. Область изменения чисел этого типа от -1.7*10+308 до -1.7*10-308 и от 1.7*10-308 до 1.7*10+308, при этом обеспечивается точность 15 десятичных цифр (точность вычисления и область изменения чисел этого типа зависят от версии компилятора, информация о них находится в файлах limits.h и float.h).
Для представления чисел с плавающей точкой используются две формы записи:
экспоненциальная, в которой запись numEexp означает число num, умноженное на 10 в степени exp (при этом, возможно, записи numEexp и numeexp являются идентичными);
обычная запись в виде десятичного числа с точкой (которая заменяет привычную для математики запятую).
По умолчанию все константы, не являющиеся целыми числами, сохраняются в виде чисел двойной точности:
double d1=0.0, d2=1.2e-125, d3=3.7E10;
long double
Единственное, что можно точно сказать о числах, объявленных числами этого типа, - они занимают не меньше места в памяти, чем числа типа double, а следовательно, обеспечивают не меньшую точность. Все остальное зависит от компилятора, поэтому этот тип следует применять только после внимательного изучения возможностей используемого компилятора, особенно в том случае, если необходимо обеспечить переносимость программного продукта.
wchar_t
Тип wchar_t используется для хранения символов, занимающих два байта (например, в стандарте Unicode). В связи с тем, что каждый символ этого типа занимает два байта, для формирования строк из него рекомендуются специальные функции. При отсутствии таких функций придется использовать присваивание для каждого символа:
wchar_t wchstr[10];
wchstr[0]='H';
wchstr[1]='i';
wchstr[2]='!';
ПРИМЕЧАНИЕ В ранних версиях С++ этот тип не поддерживался
C++: специальный справочник. / Б. Карпов, Т. Баранова - СПб: Питер, 2002. - 480 с.
|