2.4.4 Строки

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

"это строка"

Каждая строка содержит на один символ больше, чем явно задано:

все строки оканчиваются нулевым символом ('\0'), имеющим

значение 0. Поэтому

sizeof("asdf")==5;

Типом строки считается "массив из соответствующего числа символов",

поэтому тип "asdf" есть char[5]. Пустая строка записывается как

"" и имеет тип char[1]. Отметим, что для любой строки s выполняется

strlen(s)==sizeof(s)-1, поскольку функция strlen() не учитывает

завершающий символ '\0'.

Внутри строки можно использовать для представления невидимых

символов специальные комбинации с \. В частности, в строке можно

задать сам символ двойной кавычки " или символ \. Чаще всего из

таких символов оказывается нужным символ конца строки '\n', например:

cout << "звуковой сигнал в конце сообщения\007\n"

Здесь 7 - это значение в ASCII символа BEL (сигнал), который в

переносимом виде обозначается как \a.

Нет возможности задать в строке "настоящий" символ конца строки:

"это не строка,

а синтаксическая ошибка"

Для большей наглядности программы длинные строки можно разбивать

пробелами, например:

char alpha[] = "abcdefghijklmnopqrstuvwxyz"

"ABCDEFGHIJKLMNOPQRSTUVWXYZ";

Подобные, подряд идущие, строки будут объединяться в одну, поэтому

массив alpha можно эквивалентным образом инициализировать с помощью

одной строки:

"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

В строке можно задавать символ '\0', но большинство программ

не ожидает после него встречи с какими-либо еще символами. Например,

строку "asdf\000hjkl" стандартные функции strcpy() и strlen()

будут рассматривать как строку "asdf".

Если вы задаете в строке последовательностью восьмеричных цифр

числовую константу, то разумно указать все три цифры. Запись

этой строки и так не слишком проста, чтобы еще и раздумывать,

относится ли цифра к числу или является отдельным символом.

Для шестнадцатеричных констант используйте два разряда. Рассмотрим

следующие примеры:

char v1[] = "a\x0fah\0129"; // 'a' '\xfa' 'h' '\12' '9'

char v2[] = "a\xfah\129"; // 'a' '\xfa' 'h' '\12' '9'

char v3[] = "a\xfad\127"; // 'a' '\xfad' '\127'

2.4.5 Нуль

Нуль (0) имеет тип int. Благодаря стандартным преобразованиям ($$R.4)

0 можно использовать как константу целого типа, или типа с плавающей

точкой, или типа указателя. Нельзя разместить никакой объект, если

вместо адреса указан 0. Какой из типов нуля использовать, определяется

контекстом. Обычно (но необязательно) нуль представляется

последовательностью разрядов "все нули" подходящей длины.

2.5 Поименованные константы

Добавив к описанию объекта служебное слово const, можно превратить

этот объект из переменной в константу, например:

const int model = 90;

const int v[] = { 1, 2, 3, 4 };

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

инициализирована. Описывая какой-либо объект как const, мы гарантируем,

что его значение не изменяется в области видимости:

model = 200; // ошибка

model++; // ошибка

Отметим, что спецификация const скорее ограничивает возможности

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

Может быть вполне разумным и даже полезным описание функции с типом

возвращаемого значения const:

const char* peek(int i) // вернуть указатель на строку-константу

{

return hidden[i];

}

Приведенную функцию можно было бы использовать для передачи строки,

защищенной от записи, в другую программу, где она будет читаться.

Вообще говоря, транслятор может воспользоваться тем фактом, что объект

является const, для различных целей (конечно, это зависит от

"разумности" транслятора). Самое очевидное - это то, что для

константы не нужно отводить память, поскольку ее значение известно

транслятору. Далее, инициализатор для константы, как правило (но не

всегда) является постоянным выражением, которое можно вычислить на

этапе трансляции. Однако, для массива констант обычно приходится

отводить память, поскольку в общем случае транслятор не знает,

какой элемент массива используется в выражении. Но и в этом случае

на многих машинах возможна оптимизация, если поместить такой массив

в защищенную от записи память.

Задавая указатель, мы имеем дело с двумя объектами: с самим указателем

и с указуемым объектом. Если в описании указателя есть "префикс"

const, то константой объявляется сам объект, но не указатель на него,

например:

const char* pc = "asdf"; // указатель на константу

pc[3] = 'a'; // ошибка

pc = "ghjk"; // нормально

Чтобы описать как константу сам указатель, а не указуемый объект,

нужно использовать операцию * перед const. Например:

char *const cp = "asdf"; // указатель-константа

cp[3] = 'a'; // нормально

cp = "ghjk"; // ошибка

Чтобы сделать константами и указатель, и объект, надо оба объявить

const, например:

const char *const cpc = "asdf"; // указатель-константа на const

cpc[3] = 'a'; // ошибка

cpc = "ghjk"; // ошибка

Объект может быть объявлен константой при обращении к нему с помощью

указателя, и в то же время быть изменяемым, если обращаться к

нему другим способом. Особенно это удобно использовать для параметров

функции. Описав параметр-указатель функции как const, мы запрещаем

изменять в ней указуемый объект, например:

char* strcpy(char* p, const char* q); // не может изменять *q

Указателю на константу можно присвоить адрес переменной, т.к. это

не принесет вреда. Однако, адрес константы нельзя присваивать указателю

без спецификации const, иначе станет возможным менять ее значение,

например:

int a = 1;

const int c = 2;

const int* p1 = &c; // нормально

const int* p2 = &a; // нормально

int* p3 = &c; // ошибка

*p3 = 7; // меняет значение c

2.5.1. Перечисления

Есть способ связывания имен с целыми константами, который часто более

удобен, чем описание с const. Например:

enum { ASM, AUTO, BREAK };

Здесь определены три целых константы, которые называются элементами

перечисления, и им присвоены значения. Поскольку по умолчанию значения

элементов перечисления начинаются с 0 и идут в возрастающем порядке,

то приведенное перечисление эквивалентно определениям:

const ASM = 0;

const AUTO = 1;

const BREAK = 2;

Перечисление может иметь имя, например:

enum keyword { ASM, AUTO, BREAK };

Имя перечисления становится новым типом. С помощью стандартных

преобразований тип перечисления может неявно приводиться к типу int.

Обратное преобразование (из типа int в перечисление) должно быть задано

явно. Например:

void f()

{

keyword k = ASM;

int i = ASM;

k = i // ошибка

k = keyword(i);

i = k;

k = 4; // ошибка

}

Последнее преобразование поясняет, почему нет неявного преобразования

из int в перечисление: большинство значений типа int не имеет

представления в данном перечислении.

Описав переменную с типом keyword вместо очевидного int, мы дали

как пользователю, так и транслятору определенную информацию о том,

как будет использоваться эта переменная. Например, для следующего

оператора

keyword key;

switch (key) {

case ASM:

// выполнить что-либо

break;

case BREAK:

// выполнить что-либо

break;

}

транслятор может выдать предупреждение, поскольку из трех возможных

значений типа keyword используются только два.

Значения элементов перечисления можно задавать и явно. Например:

enum int16 {

sign=0100000,

most_significant=040000,

least_significant=1

};

Задаваемые значения необязательно должны быть различными, положительными

и идти в возрастающем порядке.