В программе строки, или строковые константы, представляются последовательностью изображений символов, заключенной в кавычки (не в апострофы), например “любые символы”. Среди символов строки могут быть эскейп-последовательности, соответствующие кодам не изображаемых (специальных) символьных констант.

Примеры:

“1234567890”

“\t состав президиума”

“начало строки \t и конец строки”.

В качестве терминирующего символа выбран символ с кодом 0 (не путайте его с символом "0"). Таким образом, определение

char HelloStr = "Hello, world";

фактически интерпретируется как

char HelloStr = {"H", "e", "l", "l", "o", " ", ",", "w", "o", "r", "l", "d", "\0"};

Это происходит при инициализации массива строкой. Во всех остальных случаях встретившаяся строка интерпретируется как еще не созданный безымянный массив соответствующей длины. То есть выражение

printf ("Hello, world\n");

на самом деле интерпретируется как

char str1 = "Hello, world\n";

При размещении строки в памяти транслятор автоматически добавляет в ее конец символ ‘\0’, т.е. нулевой байт.

Количество элементов в таком массиве на 1 больше, чем в изображении соответствующей строковой константы, т.к. в конец строки добавили нулевой байт ‘\0’.

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

Присвоить значение массиву символов (т.е. строке) с помощью обычного оператора присваивания нельзя. Поместить строку в массив можно либо с помощью инициализации (при определении символьного массива), либо с помощью функций ввода. В функции scanf () или printf () для символьных строк используется спецификация преобразования % s .

Пример:

/*печать символьной строки*/

#include

{ char B=”Cезам, откройся!”;

printf(“%s”,B); } /*конец программы*/

Результат выполнения программы: Сезам, откройся!

В программе длина массива В – 17 элементов, т.е. длина строки, помещаемой в массив (16 символов), плюс нулевой байт окончания строки. Именно 17 байтов выделяется при инициализации массива в приведенном примере. Инициализация массива символов с помощью строковой константы представляет собой сокращенный вариант инициализации массива и введена в язык для упрощения. Можно воспользоваться обычной инициализацией, поместив начальные значения элементов массива в фигурные скобки и не забыв при этом поместить в конце списка начальных значений специальный символ окончания строки ‘\0’. Таким образом, в программе была допустима такая инициализация массива В:

char B = {‘C’,’е’,’з’,’а’,’м’,’,’,’ ’,’о’,’т’,’к’,’р’,’о’,’й’,’с’,’я’,’!’,’\0’};

Как вводить строки или выводить их на экран?

Выводиться строка может или уже известной вам функцией printf() со спецификатором ввода "%s ", либо специальной функцией int puts (char *string), которая выводит строку string на экран и возвращает некоторое ненулевое значение в случае успеха.

Зачем нужен спецификатор "%s "? Это делается для того, чтобы можно было выводить строки с любыми символами. Сравните:

Пример:

char str = "Захотелось мне вывести %d...";

printf ("%s", str); /* Правильный вариант */

printf ("\n"); /* Разделитель новой строки */

printf (str); /* Неправильный вариант */

В первом случае функция напечатает именно то, что от нее требуется. А вот во втором случае printf() , встретив в строке str спецификатор "%d" (ведь теперь эта строка – первая, значит, она задает формат вывода), сделает вывод, что за ней должно следовать число. А так как оно не следует, то вместо "%d " будет напечатан некоторый мусор – число, находящееся в тот момент в стеке.

Последствия могут быть и более серьезными, если в строке находится последовательность "%s", то сочтет ее за строку, и будет выводить ее до тех пор, пока не встретит нулевой символ. А где она его встретит, сколько успеет напечатать и не crash"нется ли из-за обращения не к своей памяти – не знает никто.

Cоглашение о признаке окончания строки нужно соблюдать, формируя в программах строки из отдельных символов. В качестве примера рассмотрим следующую

/*чтение строки с терминала*/

int getline(char s , / *введенная строка*/

int lim) /*ее максимальная длина*/

{ int c, i; /* с – вводимый символ*/

for (i=0; i

s[i] = ’\0’;

Ввод–вывод строк. Основные функции работы со строками

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

Для ввода строки существует функция с прототипом

char *gets (char *string),

которая считывает строку с клавиатуры и помещает ее в буфер string , указатель на который и возвращает. Если произошла ошибка, то возвращается EOF.

Функция имеет только один аргумент – указатель s < stdio . h >.

Функция gets() завершает свою работу при вводе символа ‘\ n ’ , который автоматически передается с клавиатуры в ЭВМ при нажатии клавиши . При этом сам символ ‘\ n ’ во вводимую строку не записывается. Вместо него в строку помещается нуль–символ ‘\0’ . Таким образом, функция gets () производит ввод “правильной” строки , а не просто последовательности символов.

Здесь следует обратить внимание на следующую особенность ввода данных с клавиатуры. Функция gets () начинает обработку информации от клавиатуры только после нажатия клавиши < Enter >. Таким образом, она “ожидает”, пока не будет набрана нужная информация и нажата клавиша <Enter >. Только после этого начинается ввод данных в программу.

Пример: #include

int main (void) {

printf ("Input a string:");

printf ("The string input was: %s\n", string);

Функция puts () (вывод строки на экран) в случае успешного завершения возвращает последний выведенный символ, который всегда является символом ‘\ n " , если произошла ошибка, то возвращается из функции EOF. Прототип этой функции имеет следующий вид:

int puts (char*s); /*функция вывода строки*/

Функция имеет только один аргумент – указатель s на массив символов. Прототип функции описан в файле < stdio . h >.

Приведем простейший пример использования этих функций.

#include

char strl = ”введите фамилию сотрудника:”;

Напомним, что любая строка символов в языке СИ должна заканчиваться нуль–символом ‘\0’ . В последний элемент массива strl нуль–символ будет записан автоматически во время трансляции при инициализации массива. Для функции puts() наличие нуль-символа в конце строки является обязательным.

В противном случае, т.е. при отсутствии в символьном массиве символа ‘\0’ , программа может завершиться аварийно, т.к. функция puts () в поисках нуль-символа будет перебирать всю доступную память байт за байтом, начиная, в нашем примере, с адреса strl . Об этом необходимо помнить, если в программе происходит формирование строки для вывода ее на экран дисплея.

Пример : #include

int main (void) {

char string = "This is an example output string\n";

Функции манипуляции со строками

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

Для манипуляций со строками существует набор функций, объявленных в файле (те, кто пишет под Windows, могут включать вместо него файл <windows.h >).

Наиболее важные функции:

int strcmp (char *string1, char *string2)

осуществляет сравнение двух строк . Возвращает отрицательное число, если первая строка меньше второй, 0, если строки равны и положительное число, если первая строка больше второй. Более детально, функция возвращает разницу между кодами первых встретившихся неодинаковых символов (если строки неодинаковы по длине, то когда-то ненулевой символ будет сравниваться с нулем).

Пример :

#include

#include

int main (void) {

char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc";

ptr = strcmp (buf2, buf1);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1 \n");

printf("buffer 2 is less than buffer 1 \n");

ptr = strcmp(buf2, buf3);

printf("buffer 2 is greater than buffer 3\n");

printf("buffer 2 is less than buffer 3\n");

На экране появится:

buffer 2 is greater than buffer 1

buffer 2 is less than buffer 3

char *strcpy (char *dest, char *source)

осуществляет копирование строки source на место строки dest . Опять-таки позаботьтесь о том, чтобы вся строка поместилась в отведенном для нее месте. Функция возвращает указатель на строку-приемник.

Пример: #include

#include

int main (void) {

char *str1 = "a b c d e f g h i";

strcpy (string, str1);

printf("%s \n", string);

На экране появится: a b c d e f g h I

char *strcat (char *string1, char *string2)

осуществляет склеивание двух строк . Вторая строка добавляется в конец первой. Функция не проверяет (да и не может проверять технически) наличие необходимого количества памяти в конце первой строки – об этом должны позаботиться вы. Функция возвращает указатель на первую строку.

Пример:

#include

#include

int main(void) {

char destination;

char *blank = " ", *c = "C++", *turbo = "Turbo";

strcpy (destination, turbo); //Копирование строки "turbo"

на место destination

strcat (destination, blank); // Склеивание destination …

strcat (destination, c); // сначала с blank , потом с c

printf("%s\n", destination);

На экране появится: Turbo C ++

int strlen (char *string)

возвращает длину строки string (не считая нулевого символа).

char *strdup (char *string)

создает дубликат строки string и возвращает указатель на него. Учтите, что в отличие от остальных функций, strdup сама создает строку и поэтому после того, как она стала вам не нужна, не забывайте ее освободить.

char *strncpy (char *dest, char *source, int count)

char *strncat (char *string1, char *string2, int count)

аналогично strcpy и strcat , но копируются только первые count символов. Функции не добавляют к строке завершающего нуля – вам придется сделать это самим.

char *strchr (char *string, int c)

char *strstr (char *string, char *substring)

ищут первое вхождение в строку string соответственно символа c и подстроки substring . Обе функции возвращают адрес первого вхождения или NULL , если такового не найдено.

Пример :

int main (void) {

char *ptr, c = "r";

//Создаем строку

strcpy (string, "This is a string");

ptr = strchr(string, c);

printf("The character %c is at position: %d\n", c, ptr-string);

printf("The character was not found\n");

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

Константы бывают числовые, символьные и строковые. Числовые константы делятся на целочисленные и вещественные.

Целочисленные константы

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

Двоичная система представления данных непосредственно в языке Си не поддерживается. Однако можно воспользоваться файлом binary.h , в котором определены двоичные константы в пределах байта.

Пример использования двоичной системы счисления в языке Си:

1
2
3
4
5
6
7
8
9

#include
#include "binary.h"
int main()
{
unsigned char p = b10001001 | b00001010; // p=b10001011=139
printf("p = %dd = %xh" , p, p);
getchar(); getchar();
return 0;
}

Результат выполнения

В зависимости от значения целой константы компилятор присваивает ей тот или иной тип (char , int , long int ).

С помощью суффикса U (или u ) можно представить целую константу в виде беззнакового целого.

Например, Константе 200U выделяется 1 байт, и старший бит используется для представления одного из разрядов кода числа и диапазон значений становится от 0 до 255 . Суффикс L (или l ) позволяет выделить целой константе 8 байт (long int ).

Совместное использование в любом порядке суффиксов U (или u ) и L (или l ) позволяет приписать целой константе тип unsigned long int , и она займет в памяти 64 разряда, причем знаковый разряд будет использоваться для представления разряда кода (а не знака).

Вещественные константы

Константа с плавающей точкой (вещественная константа) всегда представляется числом с плавающей точкой двойной точности, т. е. как имеющая тип double , и состоит из следующих частей:

• целой части - последовательности цифр;
• точки — разделителя целой и дробной части;
• дробной части - последовательности цифр;
• символа экспоненты е или E ;
• экспоненты в виде целой константы (может быть со знаком).

Любая часть (но не обе сразу) из нижеследующих пар может быть опущена:

• целая или дробная часть;
• точка или символ е (Е ) и экспонента в виде целой константы.

Примеры вещественных констант

• 3.14159
• 2.1Е5
• .123ЕЗ
• 4037е-5

По умолчанию компилятор присваивает вещественному числу тип double . Если программиста не устраивает тип, который компилятор приписывает константе, то тип можно явно указать в записи константы с помощью следующих суффиксов:

• F (или f ) - float для простых вещественных констант,
• L (или l ) - long double для вещественных констант двойной расширенной точности.

Примеры:

• 3.14159F - константа типа float , занимающая 4 байта;
• 3.14L - константа типа long double , занимающая 10 байт.

Символьные константы

Символьная константа - это один символ, например: ‘z’ . В качестве символьных констант также могут использоваться управляющие коды, не имеющие графического представления. При этом код управляющего символа начинается с символа ‘\’ (обратный слеш).

Как правило, нажатие клавиши Enter генерирует сразу два управляющих символа — перевод строки (0x0A ) и возврат каретки (0x0D ).

Все символьные константы имеют тип char и занимают в памяти 1 байт. Значением символьной константы является числовое значение её внутреннего кода.

Строковые константы

Строковая константа - это последовательность символов, заключенная в кавычки, например:

«Это строковая константа»

Кавычки не входят в строку, а лишь ограничивают её. Технически строковая константа представляет собой массив символов, и по этому признаку может быть отнесена к разряду сложных объектов языка Си.

В конце каждой строковой константы компилятор помещает ‘\0’ (нуль-символ), чтобы программе было возможно определить конец строки. Такое представление означает, что размер строковой константы не ограничен каким-либо пределом, но для определения длины строковой константы её нужно полностью просмотреть.

Поскольку строковая константа состоит из символов, то она имеет тип char . Количество ячеек памяти, необходимое для хранения строковой константы на 1 больше количества символов в ней (1 байт используется для хранения нуль-символа).

Символьная константа ‘x’ и строка из одного символа «x» — не одно и то же. Символьная константа — это символ, используемый для числового представления буквы x, а строковая константа «x» содержит символ ‘x’ и нуль-символ ‘\0’ и занимает в памяти 2 байта. Если в программе строковые константы записаны одна за другой через разделители, то при выполнении программы они будут размещаться в последовательных ячейках памяти.

В языке Си символы заключаются в апострофы. Поэтому, когда мы присваиваем какое-то значение переменной broiled типа char , мы должны писать

broiled = " Т "; /* ПРАВИЛЬНО */,

broiled = Т; /* НЕПРАВИЛЬНО */

Если апострофы опущены, компилятор "считает", что мы используем переменную с именем Т , которую забыли описать.

В стандарте языка Си принято правило, согласно которому значениями переменной или константы типа char могут быть только одиночные символы. В соответствии с этим последовательность операторов, указанная ниже, является недопустимой, поскольку там делается попытка присвоить переменной bovine значение, состоящее из двух символов:

ehar bovine;

bovine = " ox "; /*НЕПРАВИЛЬНО */

Если вы посмотрите на таблицу кода ASCII, то увидите, что некоторые из "символов" в ней не выводятся на печать. Например, при использовании в программе символа номер 7 терминал компьютера издает звуковой сигнал. Но как использовать символ, который невозможно набрать на клавиатуре? В языке Си для этого имеются два способа.

В первом способе используется сам код ASCII. Вы должны только указать номер символа вместе с предшествующим знаком "обратная косая черта". Мы уже делали это в нашей программе "золотой эквивалент". Вот эта строка

beep = " 07 ";

Здесь имеются два важных момента, которые вы должны отчетливо представлять себе. Первый - это то, что последовательность знаков заключается в апострофы точно так же, как это делается с обычным символом. Второе - то, что номер символа должен быть записан в восьмеричном виде. При записи последовательности знаков мы можем случайно пропустить нули в первых позициях; в этом случае для представления кода "сигнал" мы могли бы использовать "7" или даже "7" . Но ни в коем случае не опускайте в записи последние нули! Последовательность символов "20" можно записать в виде "20" , но не "2" .

При использовании кода ASCII необходимо отметить различие между числами и символами, обозначающими числа. Например, символу "4" соответствует код ASCII, равный 52. Это символ "4" а не число 4.

РИС. 3. 4. Формы записи констант целых типов

Во втором способе представления "неудобных" знаков используются специальные последовательности символов. Они называются управляющими последовательностями и выглядят следующим образом:

n новая строка

t табуляция

b шаг назад

r возврат каретки

f подача бланка

обратная косая черта ()

" апостроф (")

" кавычки (")

При присваивании символьной переменной эти последовательно сти тоже должны быть заключены в апострофы. Например, мы могли бы написать оператор

nerf = " n ";

а затем вывести на печать переменную nerf; это приведет к продвижению на одну строку вперед на печатающем устройстве или на экране дисплея.

Первые пять управляющих последовательностей являются общепринятыми символами, предназначенными для управления работой печатающего устройства:

символ "новая строка" вызывает переход к новой строке;

символ "табуляция" сдвигает курсор или печатающую головку на некоторое фиксированное число позиций 5 или 8;

символ "шаг назад" производит сдвиг назад на одну позицию;

символ "возврат каретки" осуществляет возврат к началу строки;

символ "подача бланка" вызывает протяжку бумаги на одну страницу.

В последних трех управляющих последовательностях символы , " , " можно считать символьными константами [поскольку они служат для определения символьных констант и непосредственно используются в операторе printf() , применение их самих в качестве символов могло бы привести к ошибке]. Если вы хотите вывести на печать строку.

Запомните, " символ называется обратная косая черта".

оператор будет выглядеть так:

printf(" Запомните, " символ называется обратная косая черта. " n");

Здесь у вас могут возникнуть два вопроса. Во-первых, почему мы не заключили управляющие последовательности в апострофы? Во-вторых, в каких случаях необходимо использовать код ASCII и когда управляющие последовательности, которые мы только что обсуждали? (Мы надеемся, что у вас возникли как раз эти вопросы, ПОТОМУ что мы собираемся отвечать именно на них.)

Символьная константа – это некоторый символ алфавита, заключенный в одиночные кавычки: "<символ_алфавита>" .

Примеры символьных констант: " a " " B " "=" "+" " F " "[" " d ".

Значением символьной константы является целое число, равное (American Standard Code for Information Interchange, Американский стандартный код обмена информацией) данного символа. Символьная константа имеет тип int(char) и представляется 16(8)-битной величиной.

В имеются коды, которые не отображаются при печати, а производят некоторые действия, например, перевод на новую строку (LF), подача звукового сигнала, гудка – BELL) и т. д. Для таких кодов на клавиатуре не предусмотрено отдельных клавиш, и при вводе с клавиатуры они набираются сочетанием определенных клавиш: например, нажатие клавиши Ctrl и G влечет за собой поступление в память кода "гудок", а при выводе символа, имеющего значение кода "гудок", компьютер подает звуковой сигнал.

Возникает вопрос: каким образом использовать подобные коды в программе? Для этого Си предоставляет два способа, имеющих непосредственное отношение к символьным константам.

Первый способ . Любой символ в можно определить в виде символьной константы следующим образом:

"\ddd" или "\xHHH",

где ddd – восьмеричный, а HHH шестнадцатеричный код символа. Ведущие нули в представлении кода символа можно не записывать. Таким образом, в соответствии с этим вышеуказанные примеры символьных констант можно записать

	" a "	" B "			" F "		" d "

Символ, вызывающий подачу звукового сигнала, записывается в виде "\07", а символ, вызывающий перевод печати на новую строку – "\x0A".

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

Таблица 3.3. Управляющие символы

Символ Си	Символ ASCII	Название символа
		Новая строка
		Горизонтальная табуляция
		Вертикальная табуляция
		Шаг назад
		Возврат каретки
		Подача бланка
		Гудок
		Одинарная кавычка
		Двойная кавычка
		Обратная дробная черта
		Вопрос

Если управляющие символы встречаются, например, в строке вывода, то они вызывают соответствующее действие. Первые шесть управляющих символов являются символами управления работой печатающего устройства: символ "новая строка " переводит печать на начало следующей строки; символ "горизонтальная табуляция " продвигает печать в текущей строке в очередную фиксированную позицию строки. По умолчанию позиции в строке фиксируются через каждые 8 символов. Фиксированные позиции можно изменять, используя так называемые ESC-последовательности, формат которых описывается в документации по принтеру.

Символ "вертикальная табуляция " продвигает печать на начало очередных фиксированных номеров строк, которые также определяются ESC-последовательностью принтера.

Символ "шаг назад " производит сдвиг печати в текущей строке на одну позицию назад, т.е. позволяет на одном и том же знакоместе напечатать некоторое количество символов.

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

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

Сказанное не относится к символу "вопрос ". По всей вероятности, символ "вопрос" попал в число зарезервированных символов в связи с тем, что в Си имеется операция, обозначаемая знаком "?", и в некоторых ситуациях это могло бы привести к неоднозначному толкованию конструкций языка. Знак "вопрос", как символьную константу, можно записать любым рассмотренным способом: "?" "\77" "x3F" "\?" .

В заключение раздела обращаем внимание на то, что символьные константы являются целыми константами. Следовательно, допустима запись и двухсимвольных констант, например, таких: "ab" "ta" "ma" "do". Однако в этом случае их необходимо обрабатывать как данные типа int. Если двухсимвольную константу попытаться присвоить переменной типа char, то произойдет потеря второго символа.

Двухсимвольную константу можно записать в виде "\ddC" или в виде "\xHHc", где С – символ алфавита отличный от восьмеричной цифры, с – символ, отличный от шестнадцатеричной цифры. Например, "\538" все равно что "+8", ибо компилятор воспринимает \53 как восьмеричный код символа +, за которым стоит символ 8. Аналогично "\x6DQ"воспринимается как "mQ", т.е. \x6D – шестнадцатеричный код символа m, за которым записан символ Q. Мы не советуем применять такие "хитроумные штучки", хотя Си предоставляет в этом плане широчайшие возможности.

Таблица символьного типа

Для работы с расширенным набором символов используется, таких как Unicode, тип wchar _ t (широкий символ, 16 бит в Windows, 32 ,бита в GNU/Linux , но может представляться и 8 битовым значением.

В стандарте С и С++ от 2011 года введены фиксированные символьные типы char16_t and char32_t для обеспечения недвусмысленного представления 16-битового и 32 битового преобразования Unicode форматов.

Константы

Константами называют неизменяемые величины. Различаются целые, вещественные, символьные и строковые константы. Компилятор, выделив константу в качестве лексемы, относит ее к одному из типов по ее внешнему виду.

Форматы констант, соответствующие каждому типу, приведены в табл. 7.1.

Таблица 7.1.

Константы в языке С++

Константа	Формат	Примеры
Целая	Десятичный: последовательность десятичных цифр, начинающаяся не с нуля, если это не число нуль	8, 0, 199226
Восьмеричный: нуль, за которым следуют восьмеричные цифры (0,1,2,3,4,5,6,7)	01, 020, 07155
Шестнадцатеричный: Ох или ОХ, за которым следуют шестнадцатеричные цифры (0,1,2,3,4,5,6,7,8,9,А,В,С,D,Е,F)	0хА, 0x1 В8, 0Х00FF
Вещественная	Десятичный: [цифры], [цифры]	5.7, .001, 35.
Экспоненциальный: [цифры][.][цифры]{Е|е}[+|-[цифры]	0.2Е6, .11е-3, 5Е10
Символьная	Один или два символа, заключенных в апострофы	"А", ‘ю’, "*", ‘db’ ‘\0’ ‘\n’, ‘\012’ "\x07\x07"
Строковая	Последовательность символов, заключенная в кавычки	"Здесь был Vasia", "\tЗначение r=\0хF5\"

Если требуется сформировать отрицательную целую или вещественную константу, то перед константой ставится знак унарной операции изменения знака (-), например: -218, -022, -0х3С, -4.8, -0.1е4.

Вещественная константа в экспоненциальном формате представляется в виде мантиссы и порядка. Мантисса записывается слева от знака экспоненты (Е или е), порядок – справа от знака. Значение константы определяется как произведение мантиссы и возведенного в указанную в порядке степень числа 10. Обратите внимание, что пробелы внутри числа не допускаются, а для отделения целой части от дробной используется не запятая, а точка.

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

Символьные константы, состоящие из одного символа, занимают в памяти один байт и имеют стандартный тип char. Двухсимвольные константы занимают два байта и имеют тип int, при этом первый символ размещается в байте с меньшим адресом.

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

· кодов, не имеющих графического изображения (например,
\а – звуковой сигнал, \n – перевод курсора в начало следующей строки);

· символов апострофа ("), обратной косой черты (\), знака вопроса (?) и кавычки (");

· любого символа с помощью его шестнадцатеричного или восьмеричного кода, например, \073, \0xF5. Числовое значение должно находиться в диапазоне от 0 до 255.

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

Таблица 7.2.

Управляющие последовательности в языке С++

Управляющие последовательности могут использоваться и в строковых константах, называемых иначе строковыми литералами. Например, если внутри строки требуется записать кавычку, ее предваряют косой чертой, по которой компилятор отличает ее от кавычки, ограничивающей строку:

"Издательский дом \"Питер\""

Все строковые литералы рассматриваются компилятором как различные объекты.

Строковые константы, отделенные в программе только пробельными символами, при компиляции объединяются в одну. Длинную строковую константу можно разместить на нескольких строках, используя в качестве знака переноса обратную косую черту, за которой следует перевод строки. Эти символы игнорируются компилятором, при этом следующая строка воспринимается как продолжение предыдущей. Например, строка