В языке С++ определен набор базовых типов, включая арифметические типы (arithmetic type), и специальный тип void. Арифметические типы представляют символы, целые числа, логические значения и числа с плавающей запятой. С типом void не связано значений, и применяется он только при некоторых обстоятельствах, чаще всего как тип возвращаемого значения функций, которые не возвращают ничего.

 

2.1.1. Арифметические типы

Есть две разновидности арифметических типов: целочисленные типы (включая символьные и логические типы) и типы с плавающей запятой.

Размер (т.е. количество битов) арифметических типов зависит от конкретного компьютера. Стандарт гарантирует минимальные размеры, перечисленные в табл. 2.1. Однако компиляторы позволяют использовать для этих типов большие размеры. Поскольку количество битов не постоянно, значение одного типа также может занимать в памяти больше или меньше места.

Таблица 2.1. Арифметические типы языка С++

Тип bool представляет только значения true (истина) и false (ложь).

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

Остальные символьные типы, wchar_t, char16_t и char32_t, используются для расширенных наборов символов. Тип wchar_t будет достаточно большим, чтобы содержать любой символ в наибольшем расширенном наборе символов машины. Типы char16_t и char32_t предназначены для символов Unicode. (Unicode — это стандарт для представления символов, используемых, по существу, в любом языке.)

Остальные целочисленные типы представляют целочисленные значения разных размеров. Язык С++ гарантирует, что тип int будет по крайней мере не меньше типа short, а тип long long — не меньше типа long. Тип long long введен новым стандартом.

Машинный уровень представления встроенных типов

Компьютеры хранят данные как последовательность битов, каждый из которых содержит 0 или 1:

00011011011100010110010000111011 ...

Большинство компьютеров оперируют с памятью, разделенной на порции, размер которых в битах кратен степеням числа 2. Наименьшая порция адресуемой памяти называется байтом (byte). Основная единица хранения, обычно в несколько байтов, называется словом (word). В языке С++ байт содержит столько битов, сколько необходимо для содержания символа в базовом наборе символов машины. На большинстве компьютеров байт содержит 8 битов, а слово — 32 или 64 бита, т.е. 4 или 8 байтов.

У большинства компьютеров каждый байт памяти имеет номер, называемый адресом (address). На машине с 8-битовыми байтами и 32-битовыми словами слова в памяти можно было бы представить следующим образом:

FB2Library.Elements.Table.TableItem

Слева представлен адрес байта, а 8 битов его значения — справа.

При помощи адреса можно обратиться к любому из байтов, а также к набору из нескольких байтов, начинающемуся с этого адреса. В этом случае говорят о доступе к байту по адресу 736424 или о байте, хранящемуся по адресу 736426. Чтобы получить представление о значении в области памяти по данному адресу, следует знать тип хранимого в ней значения. Именно тип определяет количество используемых битов и то, как эти биты интерпретировать.

Если известно, что объект в области по адресу 736424 имеет тип float , и если тип float на этой машине хранится в 32 битах, то известно и то, что объект по этому адресу охватывает все слово. Значение этого числа зависит от того, как именно машина хранит числа с плавающей запятой. Но если объект в области по адресу 736424 имеет тип unsigned char , то на машине, использующей набор символов ISO-Latin-1, этот байт представляет точку с запятой.

Типы с плавающей точкой представляют значения с одиночной, двойной и расширенной точностью. Стандарт определяет минимальное количество значащих цифр. Большинство компиляторов обеспечивает большую точность, чем минимально определено стандартом. Как правило, тип float представляется одним словом (32 бита), тип double — двумя словами (64 бита), а тип long double — тремя или четырьмя словами (96 или 128 битов). Типы float и double обычно имеют примерно по 7 и 16 значащих цифр соответственно. Тип long double зачастую используется для адаптации чисел с плавающей запятой аппаратных средств специального назначения; его точность, вероятно, также зависит от конкретной реализации этих средств.

Знаковые и беззнаковые типы

За исключением типа bool и расширенных символьных типов целочисленные типы могут быть знаковыми (signed) или беззнаковыми (unsigned). Знаковый тип способен представлять отрицательные и положительные числа (включая нуль); а беззнаковый тип — только положительные числа и нуль.

Типы int, short, long и long long являются знаковыми. Соответствующий беззнаковый тип получают добавлением части unsigned к названию такого типа, например unsigned long. Тип unsigned int может быть сокращен до unsigned.

В отличие от других целочисленных типов, существуют три разновидности базового типа char: char, signed char и unsigned char. В частности, тип char отличается от типа signed char. На три символьных типа есть только два представления: знаковый и беззнаковый. Простой тип char использует одно из этих представлений. Какое именно, зависит от компилятора.

В беззнаковом типе все биты представляют значение. Например, 8-битовый тип unsigned char может содержать значения от 0 до 255 включительно.

Стандарт не определяет представление знаковых типов, но он указывает, что диапазон должен быть поровну разделен между положительными и отрицательными значениями. Следовательно, 8-битовый тип signed char гарантированно будет в состоянии содержать значения от -127 до 127; большинство современных машин использует представления, позволяющие содержать значения от -128 до 127.

Совет. Какой тип использовать

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

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

• Используйте тип int для целочисленной арифметики. Тип short обычно слишком мал, а тип long на практике зачастую имеет тот же размер, что и тип int . Если ваши значения больше, чем минимально гарантирует тип int , то используйте тип long long .

• Не используйте базовый тип char и тип bool в арифметических выражениях. Используйте их только для хранения символов и логических значений. Вычисления с использованием типа char особенно проблематичны, поскольку на одних машинах он знаковый, а на других беззнаковый. Если необходимо маленькое целое число, явно определите тип как signed char или unsigned char .

• Используйте тип double для вычислений с плавающей точкой. У типа float обычно недостаточно точности, а различие в затратах на вычисления с двойной и одиночной точностью незначительны. Фактически на некоторых машинах операции с двойной точностью осуществляются быстрее, чем с одинарной. Точность, предоставляемая типом long double , обычно чрезмерна и не нужна, а зачастую влечет значительное увеличение продолжительности выполнения.

Упражнения раздела 2.1.1

Упражнение 2.1. Каковы различия между типами int, long, long long и short? Между знаковыми и беззнаковыми типами? Между типами float и double?

Упражнение 2.2. Какие типы вы использовали бы для коэффициента, основной суммы и платежей при вычислении выплат по закладной? Объясните, почему вы выбрали каждый из типов?

 

2.1.2. Преобразование типов

Тип объекта определяет данные, которые он может содержать, и операции, которые с ним можно выполнять. Среди операций, поддерживаемых множеством типов, есть возможность преобразовать (convert) объект данного типа в другой, связанный тип.

Преобразование типов происходит автоматически, когда объект одного типа используется там, где ожидается объект другого типа. Более подробная информация о преобразованиях приведена в разделе 4.11, а пока имеет смысл понять, что происходит при присвоении значения одного типа объекту другого.

Когда значение одного арифметического типа присваивается другому

bool b = 42;          // b содержит true

int i = b;            // i содержит значение 1

i = 3.14;             // i содержит значение 3

double pi = i;        // pi содержит значение 3.0

unsigned char с = -1; // при 8-битовом char содержит значение 255

signed char c2 = 256; // при 8-битовом char значение c2 не определено

происходящее зависит от диапазона значении, поддерживаемых типом.

• Когда значение одного из не логических арифметических типов присваивается объекту типа bool, результат будет false, если значением является 0, а в противном случае — true.

• Когда значение типа bool присваивается одному из других арифметических типов, будет получено значение 1, если логическим значением было true, и 0, если это было false.

• Когда значение с плавающей точкой присваивается объекту целочисленного типа, оно усекается до части перед десятичной точкой.

• Когда целочисленное (интегральное) значение присваивается объекту типа с плавающей точкой, дробная часть равна нулю. Если у целого числа больше битов, чем может вместить объект с плавающей точкой, то точность может быть потеряна.

• Если объекту беззнакового типа присваивается значение не из его диапазона, результатом будет остаток от деления по модулю значения, которые способен содержать тип назначения. Например, 8-битовый тип unsigned char способен содержать значения от 0 до 255 включительно. Если присвоить ему значение вне этого диапазона, то компилятор присвоит ему остаток от деления по модулю 256. Поэтому в результате присвоения значения -1 переменной 8-битового типа unsigned char будет получено значение 255.

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

Совет. Избегайте неопределенного и машинно-зависимого поведения

Результатом неопределенного поведения являются такие ошибки, которые компилятор не обязан (а иногда и не в состоянии) обнаруживать. Даже если код компилируется, то программа с неопределенным выражением все равно ошибочна.

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

Аналогично в программах нельзя полагаться на машинно-зависимое поведение. Не стоит, например, надеяться на то, что переменная типа int имеет фиксированный, заранее известный размер. Такие программы называют непереносимыми (nonportable). При переносе такой программы на другую машину любой полагающийся на машинно-зависимое поведение код, вероятней всего, сработает неправильно, поэтому его придется искать и исправлять. Поиск подобных проблем в ранее нормально работавшей программе, мягко говоря, не самая приятная работа.

Компилятор применяет эти преобразования типов при использовании значений одного арифметического типа там, где ожидается значение другого арифметического типа. Например, при использовании значения, отличного от логического в условии, арифметическое значение преобразуется в тип bool таким же образом, как при присвоении арифметического значения переменной типа bool:

int i = 42;

if (i) // условие рассматривается как истинное

 i = 0;

При значении 0 условие будет ложным, а при всех остальных (отличных от нуля) — истинным.

К тому же при использовании значения типа bool в арифметическом выражении оно всегда преобразуется в 0 или 1. В результате применение логического значения в арифметическом выражении является неправильным.

#magnify.png Выражения, задействующие беззнаковые типы

Хотя мы сами вряд ли преднамеренно присвоим отрицательное значение объекту беззнакового типа, мы можем (причем слишком легко) написать код, который сделает это неявно. Например, если использовать значения типа unsigned и int в арифметическом выражении, значения типа int обычно преобразуются в тип unsigned. Преобразование значения типа int в unsigned выполняется таким же способом, как и при присвоении:

unsigned u = 10;

int i = -42;

std::cout << i + i << std::endl; // выводит -84

std::cout << u + i << std::endl; // при 32-битовом int,

                                 // выводит 4294967264

Во втором выражении, прежде чем будет осуществлено сложение, значение -42 типа int преобразуется в значение типа unsigned. Преобразование отрицательного числа в тип unsigned происходит точно так же, как и при попытке присвоить это отрицательное значение объекту типа unsigned. Произойдет "обращение значения" (wrap around), как было описано выше.

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

unsigned u1 = 42, u2 = 10;

std::cout << u1 - u2 << std::endl; // ok: результат 32

std::cout << u2 - u1 << std::endl; // ok: но с обращением значения

Тот факт, что беззнаковый объект не может быть меньше нуля, влияет на способы написания циклов. Например, в упражнениях раздела 1.4.1 (стр. 39) следовало написать цикл, который использовал оператор декремента для вывода чисел от 10 до 0. Написанный вами цикл, вероятно, выглядел примерно так:

for (int i = 10; i >= 0; --i)

 std::cout << i << std::endl;

Казалось бы, этот цикл можно переписать, используя тип unsigned. В конце концов, мы не планируем выводить отрицательные числа. Однако это простое изменение типа приведет к тому, что цикл никогда не закончится:

// ОШИБКА: u никогда не сможет стать меньше 0; условие

// навсегда останется истинным

for (unsigned u = 10; u >= 0; --u)

 std::cout << u << std::endl;

Рассмотрим, что будет, когда u станет равно 0. На этой итерации отображается значение 0, а затем выполняется выражение цикла for. Это выражение, --u, вычитает 1 из u. Результат, -1, недопустим для беззнаковой переменной. Как и любое другое значение, не попадающее в диапазон допустимых, это будет преобразовано в беззнаковое значение. При 32-разрядном типе int результат выражения --u при u равном 0 составит 4294967295.

Исправить этот код можно, заменив цикл for циклом while, поскольку последний осуществляет декремент прежде (а не после) отображения значения:

unsigned u = 11; // начать цикл с элемента на один больше

                 // первого, подлежащего отображению

while (u > 0) {

 --u; // сначала декремент, чтобы последняя итерация отобразила 0

 std::cout << u << std::endl;

}

Цикл начинается с декремента значения управляющей переменной цикла. В начале последней итерации переменная u будет иметь значение 1, а после декремента мы отобразим значение 0. При последующей проверке условия цикла while значением переменной u будет 0, и цикл завершится. Поскольку декремент осуществляется сначала, переменную u следует инициализировать значением на единицу больше первого подлежащего отображению значения. Следовательно, чтобы первым отображаемым значением было 10, переменную u инициализируем значением 11.

Внимание! Не смешивайте знаковые и беззнаковые типы

Выражения, в которых смешаны знаковые и беззнаковые типы, могут приводить к удивительным результатам, когда знаковое значение оказывается негативным. Важно не забывать, что знаковые значения автоматически преобразовываются в беззнаковые. Например, в таком выражении, как a * b , если а содержит значение -1 , a b значение 1 и обе переменные имеют тип int , ожидается результат -1 . Но если переменная а имеет тип int , а переменная b — тип unsigned , то значение этого выражения будет зависеть от количества битов, занимаемых типом int на данной машине. На нашей машине результатом этого выражения оказалось 4294967295 .

Упражнения раздела 2.1.2

Упражнение 2.3. Каков будет вывод следующего кода?

unsigned u = 10, u2 = 42;

std::cout << u2 - u << std::endl;

std::cout << u - u2 << std::endl;

int i = 10, i2 = 42;

std::cout << i2 - i << std::endl;

std::cout << i - i2 << std::endl;

std::cout << i - u << std::endl;

std::cout << u - i << std::endl;

Упражнение 2.4. Напишите программу для проверки правильности ответов. При неправильных ответах изучите этот раздел еще раз.

 

2.1.3. Литералы

Такое значение, как 42, в коде программы называется литералом (literal), поскольку его значение самоочевидно. У каждого литерала есть тип, определяемый его формой и значением.

Целочисленные литералы и литералы с плавающей запятой

Целочисленный литерал может быть в десятичной, восьмеричной или шестнадцатеричной форме. Целочисленные литералы, начинающиеся с нуля (0), интерпретируются как восьмеричные, а начинающиеся с 0x или 0X — как шестнадцатеричные. Например, значение 20 можно записать любым из трех следующих способов.

20   // десятичная форма

024  // восьмеричная форма

0x14 // шестнадцатеричная форма

Тип целочисленного литерала зависит от его значения и формы. По умолчанию десятичные литералы считаются знаковыми, а восьмеричные и шестнадцатеричные литералы могут быть знаковыми или беззнаковыми. Для десятичного литерала принимается наименьший тип, int, long, или long long, подходящий для его значения (т.е. первый подходящий в этом списке). Для восьмеричных и шестнадцатеричных литералов принимается наименьший тип, int, unsigned int, long, unsigned long, long long или unsigned long long, подходящий для значения литерала. Не следует использовать литерал, значение которого слишком велико для наибольшего соответствующего типа. Нет литералов типа short. Как можно заметить в табл. 2.2, значения по умолчанию можно переопределить при помощи суффикса.

Хотя целочисленные литералы могут иметь знаковый тип, с технической точки зрения значение десятичного литерала никогда не бывает отрицательным числом. Если написать нечто, выглядящее как отрицательный десятичный литерал, например -42, то знак "минус" не будет частью литерала. Знак "минус" — это оператор, который инвертирует знак своего операнда (литерала).

Литералы с плавающей запятой включают либо десятичную точку, либо экспоненту, определенную при помощи экспоненциального представления. Экспонента в экспоненциальном представлении обозначается символом E или е:

3.14159 3.14159Е0 0. 0e0 .001

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

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

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

'a'            // символьный литерал

"Hello World!" // строковый литерал

Типом строкового литерала является массив константных символов. Этот тип обсуждается в разделе 3.5.4. К каждому строковому литералу компилятор добавляет нулевой символ (null character) ('\0'). Таким образом, реальная величина строкового литерала на единицу больше его видимого размера. Например, литерал 'A' представляет один символ А, тогда как строковый литерал "А" представляет массив из двух символов, символа А и нулевого символа.

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

// многострочный литерал

std::cout << "a really, really long string literal "

             "that spans two lines" << std::endl;

Управляющие последовательности

У некоторых символов, таких как возврат на один символ или управляющий символ, нет видимого изображения. Такие символы называют непечатаемыми (nonprintable character). Другие символы (одиночные и парные кавычки, вопросительный знак и наклонная черта влево) имеют в языке специальное назначение. В программах нельзя использовать ни один из этих символов непосредственно. Для их представления как символов используется управляющая последовательность (escape sequence), начинающаяся с символа наклонной черты влево.

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

Управляющую последовательность используют как единый символ:

std::cout << '\n';      // отобразить новую строку

std::cout << "\tHi!\n"; // отобразить табуляцию,

                        // текст "Hi!" и новую строка

Можно также написать обобщенную управляющую последовательность, где за \x следует одна или несколько шестнадцатеричных цифр или за \ следует одна, две или три восьмеричные цифры. Так можно отобразить символ по его числовому значению. Вот несколько примеров (подразумевается использование набора символов Latin-1):

\7 (оповещение)    \12  (новая строка) \40 (пробел)

\0 (нулевой символ) \115 (символ 'M') \x4d (символ 'M')

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

std::cout << "Hi \x4dO\115!\n"; // выводит Hi MOM! и новую строку

std::cout << '\115' << '\n';    // выводит M и новую строку

Обратите внимание: если символ \ сопровождается более чем тремя восьмеричными цифрами, то ассоциируются с ним только первые три. Например, литерал "\1234" представляет два символа: символ, представленный восьмеричным значением 123, и символ 4. Форма \x, напротив, использует все последующие шестнадцатеричные цифры; литерал "\x1234" представляет один 16-разрядный символ, состоящий из битов, соответствующих этим четырем шестнадцатеричным цифрам. Поскольку большинство машин использует 8-битовые символы, подобные значения вряд ли будут полезны. Обычно шестнадцатеричные символы с более чем 8 битами используются для расширенных наборов символов с применением одного из префиксов, приведенных в табл. 2.2.

Определение типа литерала

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

L'a'     // литерал типа wchar_t (широкий символ)

u8"hi!"  // строковый литерал utf-8 (8-битовая кодировка Unicode)

42ULL    // целочисленный беззнаковый литерал, тип unsigned long long

1E-3F    // литерал с плавающей точкой и одинарной точностью, тип float

3.14159L // литерал с плавающей точкой и расширенной точностью,

         // тип long double

При обозначении литерала как имеющего тип long используйте букву L в верхнем регистре; строчная буква l слишком похожа на цифру 1.

Таблица 2.2. Определение типа литерала

Можно непосредственно определить знак и размер целочисленного литерала. Если суффикс содержит символ U, то у литерала беззнаковый тип. Таким образом, у десятичного, восьмеричного или шестнадцатеричного литерала с суффиксом U будет наименьший тип unsigned int, unsigned long или unsigned long long, в соответствии со значением литерала. Если суффикс будет содержать символ L, то типом литерала будет по крайней мере long; если суффикс будет содержать символы LL, то типом литерала будет long long или unsigned long long.

Можно объединить символ U с символом L или символами LL. Литерал с суффиксом UL, например, задаст тип unsigned long или unsigned long long, в зависимости от того, помещается ли его значение в тип unsigned long.

Логические литералы и литеральные указатели

Слова true и false — это логические литералы (литералы типа bool)

bool test = false;

Слово nullptr является литеральным указателем. Более подробная информация об указателях и литерале nullptr приведена в разделе 2.3.2.

Упражнения раздела 2.1.3

Упражнение 2.5. Определите тип каждого из следующих литералов. Объясните различия между ними:

(a) 'a', L'a', "a", L"a"

(b) 10, 10u, 10L, 10uL, 012, 0xC

(c) 3.14, 3.14f, 3.14L

(d) 10, 10u, 10., 10e-2

Упражнение 2.6. Имеются ли различия между следующими определениями:

int month = 9, day = 7;

int month = 09, day = 07;

Упражнение 2.7. Какие значения представляют эти литералы? Какой тип имеет каждый из них?

(a) "Who goes with F\145rgus?\012"

(b) 3.14e1L (c) 1024f (d) 3.14L

Упражнение 2.8. Напишите программу, использующую управляющие последовательности для вывода значения 2M, сопровождаемого новой строкой. Модифицируйте программу так, чтобы вывести 2, затем табуляцию, потом M и наконец символ новой строки.

 

Переменная (variable) — это именованное хранилище, которым могут манипулировать программы. У каждой переменной в языке С++ есть тип. Тип определяет размер и расположение переменной в памяти, диапазон значений, которые могут храниться в ней, и набор применимых к переменной операций. Программисты С++ используют термины "переменная" и "объект" как синонимы.

 

2.2.1. Определения переменных

Простое определение переменной состоит из спецификатора типа (type specifier), сопровождаемого списком из одного или нескольких имен переменных, отделенных запятыми, и завершающей точки с запятой. Тип каждого имени в списке задан спецификатором типа. Определение может (не обязательно) предоставить исходное значение для одного или нескольких определяемых имен:

int sum = 0, value, // sum, value и units_sold имеют тип int

    units_sold = 0; // sum и units_sold инициализированы значением 0

Sales_item item;    // item имеет тип Sales_item (см. p. 1.5.1)

// string — библиотечный тип, представляющий последовательность

// символов переменной длины

std::string book("0-201-78345-X"); // book инициализирована строковым

                                   // литералом

В определении переменной book использован библиотечный тип std::string. Подобно классу iostream (см. раздел 1.2), класс string определен в пространстве имен std. Более подробная информация о классе string приведена в главе 3, а пока достаточно знать то, что тип string представляет последовательность символов переменной длины. Библиотечный тип string предоставляет несколько способов инициализации строковых объектов. Один из них — копирование строкового литерала (см. раздел 2.1.3). Таким образом, переменная book инициализируется символами 0-201-78345-X.

Терминология. Что такое объект?

Программисты языка С++ используют термин объект (object) часто, и не всегда по делу. В самом общем определении объект — это область памяти, способная содержать данный и обладающая типом.

Одни программисты используют термин объект лишь для переменных и экземпляров классов. Другие используют его, чтобы различать именованные и неименованные объекты, причем для именованных объектов используют термин переменная (variable). Третьи различают объекты и значения, используя термин объект для тех данных, которые могут быть изменены программой, и термин значение (value) — для тех данных, которые предназначены только для чтения.

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

Инициализаторы

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

// ok: переменная price определяется и инициализируется прежде,

// чем она будет использована для инициализации переменной discount

double price = 109.99, discount = price * 0.16;

// ok: Вызов функции applyDiscount() и использование ее возвращаемого

// значения для инициализации переменной salePrice

salePrice = applyDiscount(price, discount);

Инициализация в С++ — на удивление сложная тема, и мы еще не раз вернемся к ней. Многих программистов вводит в заблуждение использование символа = при инициализации переменной. Они полагают, что инициализация — это такая форма присвоения, но в С++ инициализация и присвоение — совершенно разные операции. Эта концепция особенно важна, поскольку во многих языках это различие несущественно и может быть проигнорировано. Тем не менее даже в языке С++ это различие зачастую не имеет значения. Однако данная концепция крайне важна, и мы будем повторять это еще не раз.

Инициализация — это не присвоение. Инициализация переменной происходит при ее создании. Присвоение удаляет текущее значение объекта и заменяет его новым.

Списочная инициализация

Тема инициализации настолько сложна потому, что язык поддерживает ее в нескольких разных формах. Например, для определения переменной units_sold типа int и ее инициализации значением 0 можно использовать любой из следующих четырех способов:

int units_sold = 0;

int units_sold = {0};

int units_sold{0};

int units_sold(0);

Использование фигурных скобок для инициализации было введено новым стандартом. Ранее эта форма инициализации допускалась лишь в некоторых случаях. По причинам, описанным в разделе 3.3.1, эта форма инициализации известна как списочная инициализация (list initialization). Списки инициализаторов в скобках можно теперь использовать всегда, когда инициализируется объект, и в некоторых случаях, когда объекту присваивается новое значение.

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

long double ld = 3.1415926536;

int a{ld}, b = {ld}; // ошибка: преобразование с потерей

int с(ld), d = ld;   // ok: но значение будет усечено

Компилятор откажет в инициализации переменных а и b, поскольку использование значения типа long double для инициализации переменной типа int может привести к потере данных. Как минимум, дробная часть значения переменной ld будет усечена. Кроме того, целочисленная часть значения переменной ld может быть слишком большой, чтобы поместиться в переменную типа int.

То, что здесь представлено, может показаться тривиальным, в конце концов, вряд ли кто инициализирует переменную типа int значением типа long double непосредственно. Однако, как представлено в главе 16, такая инициализация может произойти непреднамеренно. Более подробная информация об этих формах инициализации приведена в разделах 3.2.1 и 3.3.1.

Инициализация по умолчанию

При определении переменной без инициализатора происходит ее инициализация по умолчанию (default initialization). Таким переменным присваивается значение по умолчанию (default value). Это значение зависит от типа переменной и может также зависеть от того, где определяется переменная.

Значение объекта встроенного типа, не инициализированного явно, зависит от того, где именно он определяется. Переменные, определенные вне тела функции, инициализируются значением 0. За одним рассматриваемым вскоре исключением, определенные в функции переменные встроенного типа остаются неинициализированными (uninitialized). Значение неинициализированной переменной встроенного типа неопределенно (см. раздел 2.1.2). Попытка копирования или получения доступа к значению неинициализированной переменной является ошибкой.

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

Большинство классов позволяет определять объекты без явных инициализаторов. Такие классы самостоятельно предоставляют соответствующее значение по умолчанию. Например, новый объект библиотечного класса string без инициализатора является пустой строкой.

std::string empty; // неявно инициализируется пустой строкой

Sales_item item;   // объект Sales_item инициализируется

                   // значением по умолчанию

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

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

Упражнения раздела 2.2.1

Упражнение 2.9. Объясните следующие определения. Если среди них есть некорректные, объясните, что не так и как это исправить.

(а) std::cin >> int input_value;    (b) int i = { 3.14 };

(с) double salary = wage = 9999.99; (d) int i = 3.14;

Упражнение 2.10. Каковы исходные значения, если таковые вообще имеются, каждой из следующих переменных?

std::string global str;

int global_int;

int main() {

 int local_int;

 std::string local_str;

}

 

2.2.2. Объявления и определения переменных

Для обеспечения возможности разделить программу на несколько логических частей язык С++ предоставляет технологию, известную как раздельная компиляция (separate compilation). Раздельная компиляция позволяет составлять программу из нескольких файлов, каждый из которых может быть откомпилирован независимо.

При разделении программы на несколько файлов необходим способ совместного использования кода этих файлов. Например, код, определенный в одном файле, возможно, должен использовать переменную, определенную в другом файле. В качестве конкретного примера рассмотрим объекты std::cout и std::cin. Классы этих объектов определены где-то в стандартной библиотеке, но все же наши программы могут использовать их.

Внимание! Неинициализированные переменные — причина проблем во время выполнения

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

Что же произойдет при использовании неинициализированной переменной с неопределенным значением? Иногда (если повезет) программа отказывает сразу, при попытке доступа к объекту. Обнаружив место, где происходит отказ, как правило, довольно просто выяснить, что его причиной является неправильно инициализированная переменная. Но иногда программа срабатывает, хотя результат получается ошибочным. Возможен даже худший вариант, когда на одной машине результаты получаются правильными, а на другой происходит сбой. Кроме того, добавление кода во вполне работоспособную программу в неподходящем месте тоже может привести к внезапному возникновению проблем.

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

Для поддержки раздельной компиляции язык С++ различает объявления и определения. Объявление (declaration) делает имя известным программе. Файл, который должен использовать имя, определенное в другом месте, включает объявление для этого имени. Определение (definition) создает соответствующую сущность.

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

Чтобы получить объявление, не являющееся также определением, добавляется ключевое слово extern и можно не предоставлять явный инициализатор.

extern int i; // объявить, но не определить переменную i

int j;        // объявить и определить переменную j

Любое объявление, которое включает явный инициализатор, является определением. Для переменной, определенной как extern (внешняя), можно предоставить инициализатор, но это отменит ее определение как extern. Объявление внешней переменной с инициализатором является ее определением:

extern double pi = 3.1416; // определение

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

Объявлены переменные могут быть много раз, но определены только однажды.

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

Более подробная информация о том, как язык С++ поддерживает раздельную компиляцию, приведена в разделах 2.6.3 и 6.1.3.

Упражнения раздела 2.2.2

Упражнение 2.11. Объясните, приведены ли ниже объявления или определения.

(a) extern int ix = 1024;

(b) int iy;

(c) extern int iz;

Ключевая концепция. Статическая типизация

Язык С++ обладает строгим статическим контролем типов (statically typed) данных. Это значит, что проверка соответствия значений заявленным для них типам данных осуществляется во время компиляции. Сам процесс проверки называют контролем соответствия типов (type-checking), или типизацией (typing).

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

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

 

2.2.3. Идентификаторы

Идентификаторы (identifier) (или имена) в языке С++ могут состоять из символов, цифр и символов подчеркивания. Язык не налагает ограничений на длину имен. Идентификаторы должны начинаться с букв или символа подчеркивания. Символы в верхнем и нижнем регистрах различаются, т.е. идентификаторы языка С++ чувствительны к регистру.

// определено четыре разных переменных типа int

int somename, someName, SomeName, SOMENAME;

Язык резервирует набор имен, перечисленных в табл. 2.3 и 2.4, для собственных нужд. Эти имена не могут использоваться как идентификаторы.

Таблица 2.3. Ключевые слова языка С++

Таблица 2.4. Альтернативные имена операторов языка С++

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

Соглашения об именах переменных

Существует множество общепринятых соглашений для именования переменных. Применение подобных соглашений может существенно улучшать удобочитаемость кода.

• Идентификатор должен быть осмысленным.

• Имена переменных обычно состоят из строчных символов. Например, index, а не Index или INDEX.

• Имена классов обычно начинаются с прописной буквы, например Sales_item.

• Несколько слов в идентификаторе разделяют либо символом подчеркивания, либо прописными буквами в первых символах каждого слова. Например: student_loan или studentLoan, но не studentloan.

Самым важным аспектом соглашения об именовании является его неукоснительное соблюдение.

Упражнения раздела 2.2.3

Упражнение 2.12. Какие из приведенных ниже имен недопустимы (если таковые есть)?

(a) int double = 3.14; (b) int _;

(с) int catch-22;      (d) int 1_or_2 = 1;

(e) double Double = 3.14;

 

2.2.4. Область видимости имен

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

Область видимости (scope) — это часть программы, в которой у имени есть конкретное значение. Как правило, области видимости в языке С++ разграничиваются фигурными скобками.

В разных областях видимости то же имя может относиться к разным сущностям. Имена видимы от момента их объявления и до конца области видимости, в которой они объявлены.

В качестве примера рассмотрим программу из раздела 1.4.2:

#include

int main() {

 int sum = 0;

 // сложить числа от 1 до 10 включительно

 for (int val = 1; val <= 10; ++val)

  sum += val; // эквивалентно sum = sum + val

  std::cout << "Sum of 1 to 10 inclusive is "

            << sum << std::endl;

 return 0;

}

Эта программа определяет три имени — main, sum и val, а также использует имя пространства имен std, наряду с двумя именами из этого пространства имен — cout и endl.

Имя main определено вне фигурных скобок. Оно, как и большинство имен, определенных вне функции, имеет глобальную область видимости (global scope). Будучи объявлены, имена в глобальной области видимости доступны в программе повсюду. Имя sum определено в пределах блока, которым является тело функции main(). Оно доступно от момента объявления и далее в остальной части функции main(), но не за ее пределами. Переменная sum имеет область видимости блока (block scope). Имя val определяется в пределах оператора for. Оно применимо только в этом операторе, но не в другом месте функции main().

Совет. Определяйте переменные при первом использовании

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

Вложенные области видимости

Области видимости могут содержать другие области видимости. Содержащаяся (или вложенная) область видимости называется внутренней областью видимости (inner scope), а содержащая ее области видимости — внешней областью видимости (outer scope).

Как только имя объявлено в области видимости, оно становится доступно во вложенных в нее областях видимости. Имена, объявленные во внешней области видимости, могут быть также переопределены во внутренней области видимости:

#include

// Программа предназначена исключительно для демонстрации.

// Использование в функции глобальной переменной, а также определение

// одноименной локальной переменной - это очень плохой стиль

// программирования

int reused = 42; // reused имеет глобальную область видимости

int main()

{

 int unique = 0; // unique имеет область видимости блока

 // вывод #1; используется глобальная reused; выводит 42 0

 std::cout << reused << " " << unique << std::endl;

 int reused = 0; // новый локальный объект по имени reused скрывает

                 // глобальный reused

 // вывод #2: используется локальная reused; выводит 0 0

 std::cout << reused << " " << unique << std::endl;

 // вывод #3: явное обращение к глобальной reused; выводит 42 0

 std::cout << ::reused << " " << unique << std::endl;

 return 0;

}

Вывод #1 осуществляется перед определением локальной переменной reused. Поэтому данный оператор вывода использует имя reused, определенное в глобальной области видимости. Этот оператор выводит 42 0. Вывод #2 происходит после определения локальной переменной reused. Теперь локальная переменная reused находится в области видимости (in scope). Таким образом, второй оператор вывода использует локальный объект reused, а не глобальный и выводит 0 0. Вывод #3 использует оператор области видимости (см. раздел 1.2) для переопределения стандартных правил областей видимости. У глобальной области видимости нет имени. Следовательно, когда у оператора области видимости пусто слева, это обращение к указанному справа имени в глобальной области видимости. Таким образом, это выражение использует глобальный объект reused и выводит 42 0.

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

Упражнения раздела 2.2.4

Упражнение 2.13. Каково значение переменной j в следующей программе?

int i = 42;

int main() {

 int i = 100;

 int j = i;

}

Упражнение 2.14. Допустим ли следующий код? Если да, то какие значения он отобразит на экране?

int i = 100, sum = 0;

for (int i = 0; i != 10; ++i)

 sum += i;

std::cout << i << " " << sum << std::endl;

 

Составной тип (compound type) — это тип, определенный в терминах другого типа. У языка С++ есть несколько составных типов, два из которых, ссылки и указатели, мы рассмотрим в этой главе.

У рассмотренных на настоящий момент объявлений не было ничего, кроме имен переменных. Такие переменные имели простейший, базовый тип объявления. Более сложные операторы объявления позволяют определять переменные с составными типами, которые состоят из объявлений базового типа.

 

2.3.1. Ссылки

Ссылка (reference) является альтернативным именем объекта. Ссылочный тип "ссылается на" другой тип. В определении ссылочного типа используется оператор объявления в форме &d, где d — объявляемое имя:

int ival = 1024;

int &refVal = ival; // refVal ссылается на другое имя, ival

int &refVal2;       // ошибка: ссылку следует инициализировать

Обычно при инициализации переменной значение инициализатора копируется в создаваемый объект. При определении ссылки вместо копирования значения инициализатора происходит связывание (bind) ссылки с ее инициализатором. После инициализации ссылка остается связанной с исходным объектом. Нет никакого способа изменить привязку ссылки так, чтобы она ссылалась на другой объект, поэтому ссылки следует инициализировать.

Новый стандарт ввел новый вид ссылки — ссылка r-значения (r-value reference), которую мы рассмотрим в разделе 13.6.1. Эти ссылки предназначены прежде всего для использования в классах. С технической точки зрения, когда мы используем термин ссылка (reference), мы подразумеваем ссылку l-значения (l-value reference).

#magnify.png Ссылка — это псевдоним

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

refVal = 2; // присваивает значение 2 объекту, на который ссылается

            // ссылка refVal, т.е. ival

int ii = refVal; // то же, что и ii = ival

Ссылка — это не объект, а только другое имя уже существующего объекта.

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

// ok: ссылка refVal3 связывается с объектом, с которым связана

// ссылка refVal, т.е. с ival

int &refVal3 = refVal;

// инициализирует i значением объекта, с которым связана ссылка refVal

int i = refVal; // ok: инициализирует i значением ival

Поскольку ссылки не объекты, нельзя определить ссылку на ссылку.

Определение ссылок

В одном определении можно определить несколько ссылок. Каждому являющемуся ссылкой идентификатору должен предшествовать символ &.

int i = 1024, i2 = 2048; // i и i2 — переменные типа int

int &r = i, r2 = i2;     // r — ссылка, связанная с переменной i;

                         // r2 — переменная типа int

int i3 = 1024, &ri = i3; // i3 — переменная типа int;

                         // ri — ссылка, связанная с переменной i3

int &r3 = i3, &r4 = i2;  // r3 и r4 — ссылки

За двумя исключениями, рассматриваемыми в разделах 2.4.1 и 15.2.3, типы ссылки и объекта, на который она ссылается, должны совпадать точно. Кроме того, по причинам, рассматриваемым в разделе 2.4.1, ссылка может быть связана только с объектом, но не с литералом или результатом более общего выражения:

int &refVal4 = 10;   // ошибка: инициализатор должен быть объектом

double dval = 3.14;

int &refVal5 = dval; // ошибка: инициализатор должен быть объектом

                     // типа int

Упражнения раздела 2.3.1

Упражнение 2.15. Какие из следующих определений недопустимы (если таковые есть)? Почему?

(a) int ival = 1.01;   (b) int &rval1 = 1.01;

(с) int &rval2 = ival; (d) int &rval3;

Упражнение 2.16. Какие из следующих присвоений недопустимы (если таковые есть)? Если они допустимы, объясните, что они делают.

int i = 0, &r1 = i; double d = 0, &r2 = d;

(a) r2 = 3.14159; (b) r2 = r1;

(c) i = r2;       (d) r1 = d;

Упражнение 2.17. Что выводит следующий код?

int i, &ri = i;

i = 5; ri = 10;

std::cout << i << " " << ri << std::endl;

 

2.3.2. Указатели

Указатель (pointer) — это составной тип, переменная которого указывает на объект другого типа. Подобно ссылкам, указатели используются для косвенного доступа к другим объектам. В отличие от ссылок, указатель — это настоящий объект. Указатели могут быть присвоены и скопированы; один указатель за время своего существования может указывать на несколько разных объектов. В отличие от ссылки, указатель можно не инициализировать в момент определения. Подобно объектам других встроенных типов, значение неинициализированного указателя, определенного в области видимости блока, неопределенно.

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

Тип указателя определяется оператором в форме *d, где d — определяемое имя. Символ * следует повторять для каждой переменной указателя.

int *ip1, *ip2;  // ip1 и ip2 — указатели на тип int

double dp, *dp2; // dp2 — указатель на тип double;

                 // dp — переменная типа double

Получение адреса объекта

Указатель содержит адрес другого объекта. Для получения адреса объекта используется оператор обращения к адресу (address-of operator), или оператор &.

int ival = 42;

int *p = &ival; // p содержит адрес переменной ival;

                // p - указатель на переменную ival

Второй оператор определяет p как указатель на тип int и инициализирует его адресом объекта ival типа int. Поскольку ссылки не объекты, у них нет адресов, а следовательно, невозможно определить указатель на ссылку.

За двумя исключениями, рассматриваемыми в разделах 2.4.2 и 15.2.3, типы указателя и объекта, на который он указывает, должны совпадать.

double dval;

double *pd = &dval; // ok: инициализатор - адрес объекта типа double

double *pd2 = pd;   // ok: инициализатор - указатель на тип double

int *pi = pd;       // ошибка: типы pi и pd отличаются

pi = &dval;         // ошибка: присвоение адреса типа double

                    // указателю на тип int

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

Значение указателя

Хранимое в указателе значение (т.е. адрес) может находиться в одном из четырех состояний.

1. Оно может указывать на объект.

2. Оно может указывать на область непосредственно за концом объекта

3. Это может быть нулевое значение, означающее, что данный указатель не связан ни с одним объектом.

4. Оно может быть недопустимо. Любое иное значение, кроме приведенного выше, является недопустимым.

Копирование или иная попытка доступа к значению по недопустимому указателю является серьезной ошибкой. Как и использование неинициализированной переменной, компилятор вряд ли обнаружит эту ошибку. Результат доступа к недопустимому указателю непредсказуем. Поэтому всегда следует знать, допустим ли данный указатель.

Хотя указатели в случаях 2 и 3 допустимы, действия с ними ограничены. Поскольку эти указатели не указывают ни на какой объект, их нельзя использовать для доступа к объекту. Если все же сделать попытку доступа к объекту по такому указателю, то результат будет непредсказуем.

Использование указателя для доступа к объекту

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

int ival = 42;

int *p = &ival; // p содержит адрес ival; p - указатель на ival

cout << *p;     // * возвращает объект, на который указывает p;

                // выводит 42

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

*p = 0;     // * возвращает объект; присвоение нового значения

            // ival через указатель p

cout << *p; // выводит 0

При присвоении значения *p оно присваивается объекту, на который указывает указатель p.

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

Ключевая концепция. У некоторых символов есть несколько значений

Некоторые символы, такие как & и * , используются и как оператор в выражении, и как часть объявления. Контекст, в котором используется символ, определяет то, что он означает.

int i = 42;

int &r = i;   // & следует за типом в части объявления; r - ссылка

int *p;       // * следует за типом в части объявления; p - указатель

p = &i;       // & используется в выражении как оператор

              // обращения к адресу

*p = i;       // * используется в выражении как оператор

              // обращения к значению

int &r2 = *p; // & в части объявления; * - оператор обращения к значению

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

Нулевые указатели

Нулевой указатель (null pointer) не указывает ни на какой объект. Код может проверить, не является ли указатель нулевым, прежде чем пытаться использовать его. Есть несколько способов получить нулевой указатель.

int *p1 = nullptr; // эквивалентно int *p1 = 0;

int *p2 = 0;       // непосредственно инициализирует p2 литеральной

                   // константой 0, необходимо #include cstdlib

int *p3 = NULL;    // эквивалентно int *p3 = 0;

Проще всего инициализировать указатель, используя литерал nullptr, который был введен новым стандартом. Литерал nullptr имеет специальный тип, который может быть преобразован (см. раздел 2.1.2) в любой другой ссылочный тип. В качестве альтернативы можно инициализировать указатель литералом 0, как это сделано в определении указателя p2.

Программисты со стажем иногда используют переменную препроцессора (preprocessor variable) NULL, которую заголовок cstdlib определяет как 0.

Немного подробней препроцессор рассматривается в разделе 2.6.3, а пока достаточно знать, что препроцессор (preprocessor) — это программа, которая выполняется перед компилятором. Переменные препроцессора используются препроцессором, они не являются частью пространства имен std, поэтому их указывают непосредственно, без префикса std::.

При использовании переменной препроцессора последний автоматически заменяет такую переменную ее значением. Следовательно, инициализация указателя переменной NULL эквивалентна его инициализации значением 0. Сейчас программы С++ вообще должны избегать применения переменной NULL и использовать вместо нее литерал nullptr.

Нельзя присваивать переменную типа int указателю, даже если ее значением является 0.

int zero = 0;

pi = zero; // ошибка: нельзя присвоить переменную типа int указателю

Совет. Инициализируйте все указатели

Неинициализированные указатели — обычный источник ошибок времени выполнения.

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

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

Авторы рекомендуют инициализировать все переменные, а особенно указатели. Если это возможно, определяйте указатель только после определения объекта, на который он должен указывать. Если связываемого с указателем объекта еще нет, то инициализируйте указатель значением nullptr или 0 . Так код программы может узнать, что указатель не указывает на объект.

Присвоение и указатели

И указатели, и ссылки предоставляют косвенный доступ к другим объектам. Однако есть важные различия в способе, которым они это делают. Самое важное то, что ссылка — это не объект. После того как ссылка определена, нет никакого способа заставить ее ссылаться на другой объект. При использовании ссылки всегда используется объект, с которым она была связана первоначально.

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

int i = 42;

int *pi = 0;   // указатель pi инициализирован, но не адресом объекта

int *pi2 = &i; // указатель pi2 инициализирован адресом объекта i

int *pi3;      // если pi3 определен в блоке, pi3 не инициализирован

pi3 = pi2;     // pi3 и pi2 указывают на тот же объект, т.е. на i

pi2 = 0;       // теперь pi2 не содержит адреса никакого объекта

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

pi = &ival; // значение pi изменено; теперь pi указывает на ival

С другой стороны, следующий код (использующий *pi, т.е. значение, на которое указывает указатель pi) изменяет значение объекта:

*pi = 0; // значение ival изменено; pi неизменен

Другие операции с указателями

Пока значение указателя допустимо, его можно использовать в условии. Аналогично использованию арифметических значений (раздел 2.1.2), если указатель содержит значение 0, то условие считается ложным.

int ival = 1024;

int *pi = 0;      // pi допустим, нулевой указатель

int *pi2 = &ival; // pi2 допустим, содержит адрес ival

if (pi)           // pi содержит значение 0, условие считается ложным

 // ...

if (pi2)          // pi2 указывает на ival, значит, содержит не 0;

                  // условие считается истинным

 // ...

Любой отличный от нулевого указатель рассматривается как значение true. Два допустимых указателя того же типа можно сравнить, используя операторы равенства (==) и неравенства (!=). Результат этих операторов имеет тип bool. Два указателя равны, если они содержат одинаковый адрес, и неравны в противном случае. Два указателя содержат одинаковый адрес (т.е. равны), если они оба нулевые, если они указывают на тот же объект или на область непосредственно за концом того же объекта. Обратите внимание, что указатель на объект и указатель на область за концом другого объекта вполне могут содержать одинаковый адрес. Такие указатели равны.

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

Дополнительные операции с указателями будут описаны в разделе 3.5.3.

Тип void* является специальным типом указателя, способного содержать адрес любого объекта. Подобно любому другому указателю, указатель void* содержит адрес, но тип объекта по этому адресу неизвестен.

double obj = 3.14, *pd = &obj;

// ok: void* может содержать адрес любого типа данных

void *pv = &obj; // obj может быть объектом любого типа

pv = pd;         // pv может содержать указатель на любой тип

С указателем void* допустимо немного действий: его можно сравнить с другим указателем, можно передать его функции или возвратить из нее либо присвоить другому указателю типа void*. Его нельзя использовать для работы с объектом, адрес которого он содержит, поскольку неизвестен тип объекта, неизвестны и операции, которые можно с ним выполнять.

Как правило, указатель void* используют для работы с памятью как с областью памяти, а не для доступа к объекту, хранящемуся в этой области. Использование указателей void* рассматривается в разделе 19.1.1, а в разделе 4.11.3 продемонстрировано, как можно получить адрес, хранящийся в указателе void*.

Упражнения раздела 2.3.2

Упражнение 2.18. Напишите код, изменяющий значение указателя. Напишите код для изменения значения, на которое указывает указатель.

Упражнение 2.19. Объясните основные отличия между указателями и ссылками.

Упражнение 2.20. Что делает следующая программа?

int i = 42;

int *p1 = &i;

*p1 = *p1 * *p1;

Упражнение 2.21. Объясните каждое из следующих определений. Укажите, все ли они корректны и почему.

int i = 0;

(a) double* dp = &i; (b) int *ip = i; (c) int *p = &i;

Упражнение 2.22. С учетом того, что p является указателем на тип int, объясните следующий код:

if (p) // ...

if (*p) // ...

Упражнение 2.23. Есть указатель p, можно ли определить, указывает ли он на допустимый объект? Если да, то как? Если нет, то почему?

Упражнение 2.24. Почему инициализация указателя p допустима, а указателя lp нет?

int i = 42; void *p = &i; long *lp = &i;

 

2.3.3. Понятие описаний составных типов

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

// i - переменная типа int; p - указатель на тип int;

// r - ссылка на тип int

int i = 1024, *p = &i, &r = i;

Многие программисты не понимают взаимодействия базового и модифицированного типа, который может быть частью оператора объявления.

#magnify.png Определение нескольких переменных

Весьма распространенное заблуждение полагать, что модификатор типа (* или &) применяется ко всем переменным, определенным в одном операторе. Частично причина в том, что между модификатором типа и объявляемым именем может находиться пробел.

int* p; // вполне допустимо, но может ввести в заблуждение

Данное определение может ввести в заблуждение потому, что создается впечатление, будто int* является типом каждой переменной, объявленной в этом операторе. Несмотря на внешний вид, базовым типом этого объявления является int, а не int*. Символ * — это модификатор типа p, он не имеет никакого отношения к любым другим объектам, которые могли бы быть объявлены в том же операторе:

int* p1, p2; // p1 - указатель на тип int; p2 - переменная типа int

Есть два общепринятых стиля определения нескольких переменных с типом указателя или ссылки. Согласно первому, модификатор типа располагается рядом с идентификатором:

int *p1, *p2; // p1 и p2 — указатели на тип int

Этот стиль подчеркивает, что переменная имеет составной тип. Согласно второму, модификатор типа располагается рядом с типом, но он определяет только одну переменную в операторе:

int* p1; // p1 - указатель на тип int

int* p2; // p2 - указатель на тип int

Этот стиль подчеркивает, что объявление определяет составной тип.

Нет никакого единственно правильного способа определения указателей и ссылок. Важно неукоснительно придерживаться выбранного стиля.

В этой книге используется первый стиль, знак * (или &) помещается рядом с именем переменной.

Указатели на указатели

Теоретически нет предела количеству модификаторов типа, применяемых в операторе объявления. Когда модификаторов более одного, они объединяются хоть и логичным, но не всегда очевидным способом. В качестве примера рассмотрим указатель. Указатель — это объект в памяти, и, как у любого объекта, у этого есть адрес. Поэтому можно сохранить адрес указателя в другом указателе.

Каждый уровень указателя отмечается собственным символом *. Таким образом, для указателя на указатель пишут **, для указателя на указатель на указатель — *** и т.д.

int ival = 1024;

int *pi = &ival; // pi указывает на переменную типа int

int **ppi = π // ppi указывает на указатель на переменную типа int

Здесь pi — указатель на переменную типа int, a ppi — указатель на указатель на переменную типа. Эти объекты можно было бы представить так:

#img_35.png_0

Подобно тому, как обращение к значению указателя на переменную типа int возвращает значение типа int, обращение к значению указателя на указатель возвращает указатель. Для доступа к основной объекту в этом случае необходимо обратиться к значению указателя дважды:

cout << "The value of ival\n"

     << "direct value: " << ival << "\n"

     << "indirect value: " << *pi << "\n"

     << "doubly indirect value: " << **ppi << endl;

Эта программа выводит значение переменной ival тремя разными способами: сначала непосредственно, затем через указатель pi на тип int и наконец обращением к значению указателя ppi дважды, чтобы добраться до основного значения в переменной ival.

Ссылки на указатели

Ссылка — не объект. Следовательно, не может быть указателя на ссылку. Но поскольку указатель — это объект, вполне можно определить ссылку на указатель.

int i = 42;

int *p;      // p - указатель на тип int

int *&r = p; // r - ссылка на указатель p

r = &i;      // r ссылается на указатель;

             // присвоение &i ссылке r делает p указателем на i

*r = 0;      // обращение к значению r дает i, объект, на который

             // указывает p; изменяет значение i на 0

Проще всего понять тип r — прочитать определение справа налево. Ближайший символ к имени переменной (в данном случае & в &r) непосредственно влияет на тип переменной. Таким образом, становится ясно, что r является ссылкой. Остальная часть оператора объявления определяет тип, на который ссылается ссылка r. Следующий символ, в данном случае *, указывает, что тип r относится к типу указателя. И наконец, базовый тип объявления указывает, что r — это ссылка на указатель на переменную типа int.

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

Упражнения раздела 2.3.3

Упражнение 2.25. Определите типы и значения каждой из следующих переменных:

(a) int* ip, &r = ip; (b) int i, *ip = 0; (c) int* ip, ip2;

 

Иногда необходимо определить переменную, значение которой, как известно, не может быть изменено. Например, можно было бы использовать переменную, хранящую размер буфера. Использование переменной облегчит изменение размера буфера, если мы решим, что исходный размер нас не устраивает. С другой стороны, желательно предотвратить непреднамеренное изменение в коде значения этой переменной. Значение этой переменной можно сделать неизменным, используя в ее определении спецификатор const (qualifier const):

const int bufSize = 512; // размер буфера ввода

Это определит переменную bufSize как константу. Любая попытка присвоить ей значение будет ошибкой:

bufSize = 512; // ошибка: попытка записи в константный объект

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

const int i = get_size(); // ok: инициализация во время выполнения

const int j = 42;         // ok: инициализация во время компиляции

const int k;              // ошибка: k - неинициализированная константа

Инициализация и константы

Как уже упоминалось не раз, тип объекта определяет операции, которые можно с ним выполнять. Константный тип можно использовать для большинства, но не для всех операций, как и его неконстантный аналог. Ограничение одно — можно использовать только те операции, которые неспособны изменить объект. Например, тип const int можно использовать в арифметических выражениях точно так же, как обычный неконстантный тип int. Тип const int преобразуется в тип bool тем же способом, что и обычный тип int, и т.д.

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

int i = 42;

const int ci = i; // ok: значение i копируется в ci

int j = ci;       // ok: значение ci копируется в j

Хотя переменная ci имеет тип const int, ее значение имеет тип int. Константность переменной ci имеет значение только для операций, которые могли бы изменить ее значение. При копировании переменной ci для инициализации переменной j ее константность не имеет значения. Копирование объекта не изменяет его. Как только копия сделана, у нового объекта нет никакой дальнейшей связи с исходным объектом.

По умолчанию константные объекты локальны для файла

Когда константный объект инициализируется константой во время компиляции, такой как bufSize в определении ниже, компилятор обычно заменяет используемую переменную ее значением во время компиляции.

const int bufSize = 512; // размер буфера ввода

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

Чтобы заменить переменную значением, компилятор должен видеть ее инициализатор. При разделении программы на несколько файлов, в каждом из которых используется константа, необходим доступ к ее инициализатору. Для этого переменная должна быть определена в каждом файле, в котором используется ее значение (см. раздел 2.2.2). Для обеспечения такого поведения, но все же без повторных определений той же переменной, константные переменные определяются как локальные для файла. Определение константы с тем же именем в нескольких файлах подобно написанию определения для отдельных переменных в каждом файле.

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

Для определения единого экземпляра константной переменной используется ключевое слово extern как в ее определении, так и в ее объявлениях.

// Файл file_1.cc. Определение и инициализация константы, которая

// доступна для других файлов

extern const int bufSize = fcn();

// Файл file_1.h

extern const int bufSize; // та же bufSize, определенная в file_1.cc

Здесь переменная bufSize определяется и инициализируется в файле file_1.cc. Поскольку это объявление включает инициализатор, оно (как обычно) является и определением. Но поскольку bufSize константа, необходимо применить ключевое слово extern, чтобы использовать ее в других файлах.

Объявление в заголовке file_1.h также использует ключевое слово extern. В данном случае это демонстрирует, что имя bufSize не является локальным для этого файла и что его определение находится в другом месте.

Чтобы совместно использовать константный объект в нескольких файлах, его необходимо определить с использованием ключевого слова extern.

Упражнения раздела 2.4

Упражнение 2.26. Что из приведенного ниже допустимо? Если что-то недопустимо, то почему?

(a) const int buf;      (b) int cnt = 0;

(c) const int sz = cnt; (d) ++cnt; ++sz;

 

2.4.1. Ссылка на константу

Подобно любым другим объектам, с константным объектом можно связать ссылку. Для этого используется ссылка на константу (reference to const), т.е. ссылка на объект типа const. В отличие от обычной ссылки, ссылку на константу нельзя использовать для изменения объекта, с которым она связана.

const int ci = 1024;

const int &r1 = ci; // ok: и ссылка, и основной объект - константы

r1 = 42;            // ошибка: r1 - ссылка на константу

int &r2 = ci; // ошибка: неконстантная ссылка на константный объект

Поскольку нельзя присвоить значение самой переменной ci, ссылка также не должна позволять изменять ее. Поэтому инициализация ссылки r2 — это ошибка. Если бы эта инициализация была допустима, то ссылку r2 можно было бы использовать для изменения значения ее основного объекта.

Терминология. Константная ссылка — это ссылка на константу

Программисты С++, как правило, используют термин константная ссылка (const reference), однако фактически речь идет о ссылке на константу (reference to const).

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

Инициализация и ссылки на константу

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

int i = 42;

const int &r1 = i;      // можно связать ссылку const int& с обычным

                        // объектом int

const int &r2 =42;      // ok: r1 - ссылка на константу

const int &r3 = r1 * 2; // ok: r3 - ссылка на константу

int &r4 = r * 2;        // ошибка: r4 - простая, неконстантная ссылка

Простейший способ понять это различие в правилах инициализации — рассмотреть то, что происходит при связывании ссылки с объектом другого типа:

double dval = 3.14;

const int &ri = dval;

Здесь ссылка ri ссылается на переменную типа int. Операции со ссылкой ri будут целочисленными, но переменная dval содержит число с плавающей запятой, а не целое число. Чтобы удостовериться в том, что объект, с которым связана ссылка ri, имеет тип int, компилятор преобразует этот код в нечто следующее:

const int temp = dval; // создать временную константу типа int из

                       // переменной типа double

const int &ri = temp;  // связать ссылку ri с временной константой

В данном случае ссылка ri связана с временным объектом (temporary). Временный объект — это безымянный объект, создаваемый компилятором для хранения промежуточного результата вычисления. Программисты С++ зачастую используют слово "temporary" как сокращение термина "temporary object".

Теперь рассмотрим, что могло бы произойти, будь инициализация позволена, но ссылка ri не была бы константной. В этом случае мы могли бы присвоить значение по ссылке ri. Это изменило бы объект, с которым связана ссылка ri. Этот временный объект имеет тип не dval. Программист, заставивший ссылку ri ссылаться на переменную dval, вероятно, ожидал, что присвоение по ссылке ri изменит переменную dval. В конце концов, почему произошло присвоение по ссылке ri, если не было намерения изменять объект, с которым она связана? Поскольку связь ссылки с временным объектом осуществляет уж конечно не то, что подразумевал программист, язык считает это некорректным.

Ссылка на константу может ссылаться на неконстантный объект

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

int i = 42;

int &r1 = i;       // r1 связана с i

const int &r2 = i; // r2 тоже связана с i;

                   // но она не может использоваться для изменения i

r1 = 0;            // r1 - неконстантна; i теперь 0

r2 = 0;            // ошибка: r2 - ссылка на константу

Привязка ссылки r2 к неконстантной переменной i типа int вполне допустима. Но ссылку r2 нельзя использовать для изменения значения переменной i. Несмотря на это, значение переменной i вполне можно изменить другим способом, Например, можно присвоить ей значение непосредственно или при помощи другой связанной с ней ссылки, такой как r1.

 

2.4.2. Указатели и спецификатор

const

Подобно ссылкам, вполне возможно определять указатели, которые указывают на объект константного или неконстантного типа. Как и ссылку на константу (см. раздел 2.4.1), указатель на константу (pointer to const) невозможно использовать для изменения объекта, на который он указывает. Адрес константного объекта можно хранить только в указателе на константу:

const double pi = 3.14;   // pi - константа; ее значение неизменно

double *ptr = π        // ошибка: ptr - простой указатель

const double *cptr = π // ok: cptr может указывать на тип

                          //  const double

*cptr = 42;               // ошибка: нельзя присвоить *cptr

В разделе 2.3.2 упоминалось о наличии двух исключений из правила, согласно которому типы указателя и объекта, на который он указывает, должны совпадать. Первое исключение — это возможность использования указателя на константу для указания на неконстантный объект:

double dval = 3.14; // dval типа double; ее значение неизменно

cptr = &dval;       // ok: но изменить dval при помощи cptr нельзя

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

Возможно, указатели и ссылки на константы следует рассматривать как указатели или ссылки, "которые полагают, что они указывают или ссылаются на константы".

Константные указатели

В отличие от ссылок, указатели — это объекты. Следовательно, подобно любым другим объектам, вполне может быть указатель, сам являющийся константой. Как и любой другой константный объект, константный указатель следует инициализировать, после чего изменить его значение (т.е. адрес, который он содержит) больше нельзя. Константный указатель объявляют, расположив ключевое слово const после символа *. Это означает, что данный указатель является константой, а не обычным указателем на константу.

int errNumb = 0;

int *const curErr = &errNumb; // curErr всегда будет указывать на errNumb

const double pi = 3.14159;

const double *const pip = π // pip константный указатель на

                               // константный объект

Как уже упоминалось в разделе 2.3.3, проще всего понять эти объявления, читая их справа налево. В данном случае ближе всего к имени curErr расположен спецификатор const, означая, что сам объект curErr будет константным. Тип этого объекта формирует остальная часть оператора объявления. Следующий символ оператора объявления, *, означает, что curErr — это константный указатель. И наконец, объявление завершает базовый тип, означая, что curErr — это константный указатель на объект типа int. Аналогично pip — это константный указатель на объект типа const double.

Тот факт, что указатель сам является константой, ничто не говорит о том, можем ли мы использовать указатель для изменения основного объекта. Возможность изменения объекта полностью зависит от типа, на который указывает указатель. Например, pip — это константный указатель на константу. Ни значение объекта, на который указывает указатель pip, ни хранящийся в нем адрес не могут быть изменены. С другой стороны, указатель curErr имеет простой, неконстантный тип int. Указатель curErr можно использовать для изменения значения переменной errNumb:

*pip = 2.72; // ошибка: pip - указатель на константу

// если значение объекта, на который указывает указатель curErr

// (т.е. errNumb), отлично от нуля

if (*curErr) {

 errorHandler();

 *curErr = 0; // обнулить значение объекта, на который

              // указывает указатель curErr

}

Упражнения раздела 2.4.2

Упражнение 2.27. Какие из следующих инициализаций допустимы? Объясните почему.

(a) int i = -1, &r = 0;       (b) int *const p2 = &i2;

(c) const int i = -1, &r = 0; (d) const int *const p3 = &i2;

(e) const int *p1 = &i2;      (f) const int &const r2;

(g) const int i2 = i, &r = i;

Упражнение 2.28. Объясните следующие определения. Какие из них недопустимы?

(a) int i, *const cp;      (b) int *p1, *const p2;

(c) const int ic, &r = ic; (d) const int *const p3;

(e) const int *p;

Упражнение 2.29. С учетом переменных из предыдущих упражнений, какие из следующих присвоений допустимы? Объясните почему.

(a) i = ic;   (b) pi = p3;

(с) pi = ⁣ (d) p3 = ⁣

(e) p2 = pi;  (f) ic = *p3;

 

2.4.3. Спецификатор

const

верхнего уровня

Как уже упоминалось, указатель — это объект, способный указывать на другой объект. В результате можно сразу сказать, является ли указатель сам константой и являются ли константой объекты, на которые он может указывать. Термин спецификатор const верхнего уровня (top-level const) используется для обозначения того ключевого слова const, которое объявляет константой сам указатель. Когда указатель способен указывать на константный объект, это называется спецификатор const нижнего уровня (low-level const). 

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

int i = 0;

int *const pi = &i;  // нельзя изменить значение pi;

                     // const верхнего уровня

const int ci = 42;   // нельзя изменить ci; const верхнего уровня

const int *p2 = &ci; // нельзя изменить p2; const нижнего уровня

const int *const p3 = p2; // справа const верхнего уровня, слева нет

const int &r = ci;   // const в ссылочных типах всегда нижнего уровня

Различие между спецификаторами const верхнего и нижнего уровней проявляется при копировании объекта. При копировании объекта спецификатор const верхнего уровня игнорируется.

i = ci;  // ok: копирование значения ci; спецификатор const верхнего

         // уровня в ci игнорируется

p2 = p3; // ok: указываемые типы совпадают; спецификатор const верхнего

         // уровня в p3 игнорируется

Копирование объекта не изменяет копируемый объект. Поэтому несущественно, является ли копируемый или копирующий объект константой.

Спецификатор const нижнего уровня, напротив, никогда не игнорируется. При копировании объектов у них обоих должны быть одинаковые спецификаторы const нижнего уровня, или должно быть возможно преобразование между типами этих двух объектов. Как правило, преобразование неконстанты в константу возможно, но не наоборот.

int *p = p3;       // ошибка: p3 имеет const нижнего уровня, а p - нет

p2 = p3;           // ok: p2 имеет то же const нижнего уровня, что и p3

p2 = &i;           // ok: преобразование int* в const int* возможно

int &r = ci;       // ошибка: невозможно связать обычную int& с

                   // объектом const int

const int &r2 = i; // ok: const int& можно связать с обычным int

У указателя p3 есть спецификатор const нижнего и верхнего уровня. При копировании указателя p3 можно проигнорировать его спецификатор const верхнего уровня, но не тот факт, что он указывает на константный тип. Следовательно, нельзя использовать указатель p3 для инициализации указателя p, который указывает на простой (неконстантный) тип int. С другой стороны, вполне можно присвоить указатель p3 указателю p2. У обоих указателей тот же тип (спецификатор const нижнего уровня). Тот факт, что p3 — константный указатель (т.е. у него есть спецификатор const верхнего уровня), не имеет значения.

Упражнения раздела 2.4.3

Упражнение 2.30. Укажите по каждому из следующих объявлений, имеет ли объявляемый объект спецификатор const нижнего или верхнего уровня.

const int v2 = 0;

int v1 = v2;

int *p1 = &v1, &r1 = v1;

const int *p2 = &v2, *const p3 = &i, &r2 = v2;

Упражнение 2.31. С учетом объявлений в предыдущем упражнении укажите, допустимы ли следующие присвоения. Объясните, как спецификатор const верхнего или нижнего уровня применяется в каждом случае.

r1 = v2;

p1 = p2; р2 = p1;

p1 = p3; p2 = p3;

 

2.4.4. Переменные

constexpr

и константные выражения

Константное выражение (constant expression) — это выражение, значение которого не может измениться и вычисляется во время компиляции. Литерал — это константное выражение. Константный объект, инициализируемый константным выражением, также является константным выражением. Вскоре мы увидим, что в языке есть несколько контекстов, требующих константных выражений.

Является ли данный объект (или выражение) константным выражением, зависит от типов и инициализаторов. Например:

const int max_files = 20;  // max_files - константное выражение

const int limit = max_files + 1; // limit - константное выражение

int staff_size = 27;       // staff_size - неконстантное выражение

const int sz = get_size(); // sz - неконстантное выражение

Хотя переменная staff_size инициализируется литералом, это неконстантное выражение, поскольку он имеет обычный тип int, а не const int. С другой стороны, хоть переменная sz и константа, значение ее инициализатора неизвестно до времени выполнения. Следовательно, это неконстантное выражение.

Переменные constexpr

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

Согласно новому стандарту, можно попросить компилятор проверить, является ли переменная константным выражением, использовав в ее объявлении ключевое слово constexpr. Переменные constexpr неявно являются константой и должны инициализироваться константными выражениями.

constexpr int mf = 20;        // 20 - константное выражение

constexpr int limit = mf + 1; // mf + 1 - константное выражение

constexpr int sz = size();    // допустимо, только если size() является

                              // функцией constexpr

Хоть и нельзя использовать обычную функцию как инициализатор для переменной constexpr, как будет описано в разделе 6.5.2, новый стандарт позволяет определять функции как constexpr. Такие функции должны быть достаточно просты, чтобы компилятор мог выполнить их во время компиляции. Функции constexpr можно использовать в инициализаторе переменной constexpr.

Как правило, ключевое слово constexpr имеет смысл использовать для переменных, которые предполагается использовать как константные выражения.

Литеральные типы

Поскольку константное выражение обрабатывается во время компиляции, есть пределы для типов, которые можно использовать в объявлении constexpr. Типы, которые можно использовать в объявлении constexpr, известны как литеральные типы (literal type), поскольку они достаточно просты для литеральных значений.

Все использованные до сих пор типы — арифметический, ссылка и указатель — это литеральные типы. Наш класс Sales_item и библиотечный тип string не относятся к литеральным типам. Следовательно, нельзя определить переменные этих типов как constexpr. Другие виды литеральных типов рассматриваются в разделах 7.5.6 и 19.3.

Хотя указатели и ссылки можно определить как constexpr, используемые для их инициализации объекты жестко ограничены. Указатель constexpr можно инициализировать литералом nullptr или литералом (т.е. константным выражением) 0. Можно также указать на (или связать с) объект, который остается по фиксированному адресу.

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

Указатели и спецификатор constexpr

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

const int *p = nullptr;     // p - указатель на const int

constexpr int *q = nullptr; // q - константный указатель на int

Несмотря на внешний вид, типы p и q весьма различны; p — указатель на константу, тогда как q — константный указатель. Различие является следствием того факта, что спецификатор constexpr налагает на определяемый объект спецификатор const верхнего уровня (см. раздел 2.4.3).

Как и любой другой константный указатель, указатель constexpr может указать на константный или неконстантный тип.

constexpr int *np = nullptr; // np - нулевой константный указатель

                             //  на int

int j = 0;

constexpr int i = 42;        // типом i является const int

// i и j должны быть определены вне любой функции

constexpr const int *p = &i; // p - константный указатель

                             //  на const int i

constexpr int *p1 = &j;      // p1 - константный указатель на int j

Упражнения раздела 2.4.4

Упражнение 2.32. Допустим ли следующий код? Если нет, то как его исправить?

int null = 0, *p = null;

 

По мере усложнения программ используемые в них типы также становятся все более сложными. Осложнения в использовании типов возникают по двум причинам. Имена некоторых типов трудно писать по памяти. Написание некоторых их форм утомительно и подвержено ошибкам. Кроме того, формат записи сложного типа способен скрыть его цель или значение. Другой источник осложнений кроется в том, что иногда трудно точно определить необходимый тип. Это может потребовать оглянуться на контекст программы.

 

2.5.1. Псевдонимы типов

Псевдоним типа (type alias) — это имя, являющееся синонимом имени другого типа. Псевдонимы типа позволяют упростить сложные определения типов, облегчая их использование. Псевдонимы типа позволяют также подчеркивать цель использования типа. Определить псевдоним типа можно одним из двух способов. Традиционно он определяется при помощи ключевого слова typedef:

typedef double wages;   // wages - синоним для double

typedef wages base, *p; // base - синоним для double, a p - для double*

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

Новый стандарт вводит второй способ определения псевдонима типа при помощи объявления псевдонима (alias declaration) и знака =.

using SI = Sales_item; // SI - синоним для Sales_item

Объявление псевдонима задает слева от оператора = имя псевдонима типа, который расположен справа.

Псевдоним типа — это имя типа, оно может присутствовать везде, где присутствует имя типа.

wages hourly, weekly; // то же, что и double hourly, weekly;

SI item;              // то же, что и Sales_item item

#magnify.png Указатели, константы и псевдонимы типа

Объявления, использующие псевдонимы типа, представляющие составные типы и константы, могут приводить к удивительным результатам. Например, следующие объявления используют тип pstring, который является псевдонимом для типа char*.

typedef char *pstring;

const pstring cstr = 0; // cstr - константный указатель на char

const pstring *ps;      // ps - указатель на константный указатель

                        // на тип char

Базовым типом в этих объявлениях является const pstring. Как обычно, модификатор const в базовом типе модифицирует данный тип. Тип pstring — это указатель на тип char, a const pstring — это константный указатель на тип char, но не указатель на тип const char.

Заманчиво, хоть и неправильно, интерпретировать объявление, которое использует псевдоним типа как концептуальную замену псевдонима, соответствующим ему типом:

const char *cstr = 0; // неправильная интерпретация const pstring cstr

Однако эта интерпретация неправильна. Когда используется тип pstring в объявлении, базовым типом объявления является тип указателя. При перезаписи объявления с использованием char*, базовым типом будет char, а * будет частью оператора объявления. В данном случае базовый тип — это const char. Перезапись объявляет cstr указателем на тип const char, а не константным указателем на тип char.

 

2.5.2. Спецификатор типа

auto

Нет ничего необычного в желании сохранить значение выражения в переменной. Чтобы объявить переменную, нужно знать тип этого выражения. Когда мы пишем программу, может быть на удивление трудно (а иногда даже невозможно) определить тип выражения. По новому стандарту можно позволить компилятору самому выяснять этот тип. Для этого используется спецификатор типа auto. В отличие от таких спецификаторов типа, как double, задающих определенный тип, спецификатор auto приказывает компилятору вывести тип из инициализатора. Само собой разумеется, у переменной, использующей спецификатор типа auto, должен быть инициализатор.

// тип item выводится из типа результата суммы val1 и val2

auto item = val1 + val2; // item инициализируется результатом val1 + val2

Здесь компилятор выведет тип переменной item из типа значения, возвращенного при применении оператора + к переменным val1 и val2. Если переменные val1 и val2 — объекты класса Sales_item (см. раздел 1.5), типом переменной item будет класс Sales_item. Если эти переменные имеют тип double, то у переменной item будет тип double и т.д.

Подобно любому другому спецификатору типа, используя спецификатор auto, можно определить несколько переменных. Поскольку объявление может задействовать только один базовый тип, у инициализаторов всех переменных в объявлении должны быть типы, совместимые друг с другом.

auto i = 0, *p = &i;    // ok: i - int, а p - указатель на int

auto sz = 0, pi = 3.14; // ошибка: несовместимые типы у sz и pi

Составные типы, const и auto

Выводимый компилятором тип для спецификатора auto не всегда точно совпадает с типом инициализатора. Компилятор корректирует тип так, чтобы он соответствовал обычным правилам инициализации.

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

int i = 0, &r = i;

auto a = r; // a - int (r - псевдоним для i, имеющий тип int)

Во-вторых, выведение типа auto обычно игнорирует спецификаторы const верхнего уровня (см. раздел 2.4.3). Как обычно в инициализациях, спецификаторы const нижнего уровня учитываются в случае, когда инициализатор является указателем на константу.

const int ci = i, &cr = ci;

auto b = ci;  // b - int (const верхнего уровня в ci отброшен)

auto с = cr;  // с - int (cr - псевдоним для ci с const верхнего

              //  уровня)

auto d = &i;  // d - int* (& объекта int - int*)

auto e = &ci; // e - const int* (& константного объекта - const нижнего

              // уровня)

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

const auto f = ci; // выведенный тип ci - int; тип f - const int

Можно также указать, что необходима ссылка на автоматически выведенный тип. Обычные правила инициализации все еще применимы.

auto &g = ci; // g - const int&, связанный с ci

auto &h = 42; // ошибка: нельзя связать простую ссылку с литералом

const auto &j = 42; // ok: константную ссылку с литералом связать можно

Когда запрашивается ссылка на автоматически выведенный тип, спецификаторы const верхнего уровня в инициализаторе не игнорируются. Как обычно при связывании ссылки с инициализатором, спецификаторы const не относятся к верхнему уровню.

При определении нескольких переменных в том же операторе важно не забывать, что ссылка или указатель — это часть специфического оператора объявления, а не часть базового типа объявления. Как обычно, инициализаторы должны быть совместимы с автоматически выведенными типами:

auto k = ci, &l = i;    // k - int; l - int&

auto &m = ci, *p = &ci; // m - const int&; p - указатель на const int

// ошибка: выведение типа из i - int;

//  тип, выведенный из &ci - const int

auto &n = i, *p2 = &ci;

Упражнения раздела 2.5.2

Упражнение 2.33. С учетом определения переменных из этого раздела укажите то, что происходит в каждом из этих присвоений.

а = 42; b = 42; с = 42;

d = 42; е = 42; g = 42;

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

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

const int i = 42;

auto j = i; const auto &k = i; auto *p = &i;

const auto j2 = i, &k2 = i;

 

2.5.3. Спецификатор типа

decltype

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

decltype(f()) sum = x; // sum имеет тот тип,

                       //  который возвращает функция f

Здесь компилятор не вызывает функцию f(), но он использует тип, который возвратил бы такой вызов для переменной sum. Таким образом, компилятор назначает переменной sum тот же тип, который был бы возвращен при вызове функции f().

Таким образом, спецификатор decltype учитывает спецификатор const верхнего уровня и ссылки, но несколько отличается от того, как работает спецификатор auto. Когда выражение, к которому применен спецификатор decltype, является переменной, он возвращает тип этой переменной, включая спецификатор const верхнего уровня и ссылки.

const int ci = 0, &cj = ci;

decltype(ci) x = 0; // x имеет тип const int

decltype(cj) y = x; //  y имеет тип const int& и связана с x

decltype(сj) z; // ошибка: z - ссылка, она должна быть инициализирована

Поскольку cj — ссылка, decltype (cj) — ссылочный тип. Как и любую другую ссылку, ссылку z следует инициализировать. 

Следует заметить, что спецификатор decltype — единственный контекст, в котором переменная определена, поскольку ссылка не рассматривается как синоним объекта, на который она ссылается.

#books.png Спецификатор decltype и ссылки

Когда спецификатор decltype применяется к выражению, которое не является переменной, получаемый тип соответствует типу выражения. Как будет продемонстрировано в разделе 4.1.1, некоторые выражения заставят спецификатор decltype возвращать ссылочный тип. По правде говоря, спецификатор decltype возвращает ссылочный тип для выражений, результатом которых являются объекты, способные стоять слева от оператора присвоения.

// decltype выражение может быть ссылочным типом

int i = 42, *p = &i, &r = i;

decltype(r + 0) b; // ok: сложение возвращает тип int; b имеет тип int

                   // (не инициализирована)

decltype(*p) с;    // ошибка: с имеет тип int& и требует инициализации

Здесь r — ссылка, поэтому decltype(r) возвращает ссылочный тип. Если необходим тип, на который ссылается ссылка r, можно использовать ее в таком выражении, как r + 0, поскольку оно возвращает значение не ссылочного типа.

С другой стороны, оператор обращения к значению — пример выражения, для которого спецификатор decltype возвращает ссылку. Как уже упоминалось, при обращении к значению указателя возвращается объект, на который он указывает. Кроме того, этому объекту можно присвоить значение. Таким образом, decltype(*p) выведет тип int&, а не просто int.

Еще одно важное различие между спецификаторами decltype и auto в том, что выведение, осуществляемое спецификатором decltype, зависит от формы данного выражения. Не всегда понимают то, что включение имени переменной в круглые скобки влияет на тип, возвращаемый спецификатором decltype. При применении спецификатора decltype к переменной без круглых скобок получается тип этой переменной. Если заключить имя переменной в одни или несколько круглых скобок, то компилятор будет рассматривать операнд как выражение. Переменная — это выражение, которое способно быть левым операндом присвоения. В результате спецификатор decltype для такого выражения возвратит ссылку.

// decltype переменной в скобках - всегда ссылка

decltype((i)) d; // ошибка: d - int& и должна инициализироваться

decltype(i) e;   // ok: e имеет тип int (не инициализирована)

Помните, что спецификатор decltype(( переменная )) (обратите внимание на парные круглые скобки) всегда возвращает ссылочный тип, а спецификатор decltype( переменная ) возвращает ссылочный тип, только если переменная является ссылкой.

Упражнения раздела 2.5.3

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

int а = 3, b = 4;

decltype(а) с = а;

decltype((b)) d = а;

++c;

++d;

Упражнение 2.37. Присвоение — это пример выражения, которое возвращает ссылочный тип. Тип — это ссылка на тип левого операнда. Таким образом, если переменная i имеет тип int, то выражение i = x имеет тип int&. С учетом этого определите тип и значение каждой переменной в следующем коде:

int а = 3, b = 4;

decltype(а) с = а;

decltype(а = b) d = а;

Упражнение 2.38. Опишите различия выведения типа спецификаторами decltype и auto. Приведите пример выражения, где спецификаторы auto и decltype выведут тот же тип, и пример, где они выведут разные типы.

 

На самом простом уровне структура данных (data structure) — это способ группировки взаимосвязанных данных и стратегии их использования. Например, класс Sales_item группирует ISBN книги, количество проданных экземпляров и выручку от этой продажи. Он предоставляет также набор операций, таких как функция isbn() и операторы >>, <<, + и +=.

В языке С++ мы создаем собственные типы данных, определяя класс. Такие библиотечные типы, как string, istream и ostream, определены как классы, подобно типу Sales_item в главе 1. Поддержка классов в языке С++ весьма обширна, фактически части III и IV в значительной степени посвящены описанию средств, связанных с классами. Хотя класс Sales_item довольно прост, мы не сможем определить его полностью, пока не узнаем в главе 14, как писать собственные операторы.

 

2.6.1 Определение типа

Sales_data

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

Поскольку создаваемая структура данных не поддерживает операций, назовем новую версию Sales_data, чтобы отличать ее от типа Sales_item. Определим класс следующим образом:

struct Sales_data {

 std::string bookNo;

 unsigned units_sold = 0;

 double revenue = 0.0;

};

Класс начинается с ключевого слова struct, сопровождаемого именем класса и (возможно пустым) телом класса. Тело класса заключено в фигурные скобки и формирует новую область видимости (см. раздел 2.2.4). Определенные в классе имена должны быть уникальны в пределах класса, но вне класса они могут повторяться.

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

struct Sales_data { /* ... */ } accum, trans, *salesptr;

// эквивалентно, но лучше определять эти объекты так

struct Sales_data { /* ... */ };

Sales data accum, trans, *salesptr;

Точка с запятой отмечает конец (обычно пустого) списка объявления операторов. Обычно определение объекта в составе определения класса — это не лучшая идея. Объединение в одном операторе определений двух разных сущностей (класса и переменной) ухудшает читабельность кода.

Забытая точка с запятой в конце определения класса — довольно распространенная ошибка начинающих программистов.

Переменные-члены класса

В теле класса определены члены (member) класса. У нашего класса есть только переменные-члены (data member). Переменные-члены класса определяют содержимое объектов этого класса. Каждый объект обладает собственным экземпляром переменных-членов класса. Изменение переменных-членов одного объекта не изменяет данные в любом другом объекте класса Sales_data.

Переменные-члены определяют точно так же, как и обычные переменные: указывается базовый тип, затем список из одного или нескольких операторов объявления. У нашего класса будут три переменные-члены: член типа string по имени bookNo, член типа unsigned по имени units_sold и член типа double по имени revenue. Эти три переменные-члены будут у каждого объекта класса Sales_data.

По новому стандарту переменной-члену можно предоставить внутриклассовый инициализатор (in-class initializer). Он используется для инициализации переменных-членов при создании объектов. Члены без инициализатора инициализируются по умолчанию (см. раздел 2.2.1). Таким образом, при определении объектов класса Sales_data переменные-члены units_sold и revenue будут инициализированы значением 0, а переменная-член bookNo — пустой строкой.

Внутриклассовые инициализаторы ограничены формой их использования (см. раздел 2.2.1): они должны либо быть заключены в фигурные скобки, либо следовать за знаком =. Нельзя определить внутриклассовый инициализатор в круглых скобках.

В разделе 7.2 указано, что язык С++ обладает еще одним ключевым словом, class, также используемым для определения собственной структуры данных. В этом разделе используем ключевое слово struct, поскольку пока еще не рассмотрены приведенные в главе 7 дополнительные средства, связанные с классом.

Упражнения раздела 2.6.1

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

struct Foo { /* пусто */ } // Примечание: нет точки с запятой

int main() {

 return 0;

}

Упражнение 2.40. Напишите собственную версию класса Sales_data.

 

2.6.2. Использование класса

Sales_data

В отличие от класса Sales_item, класс Sales_data не поддерживает операций. Пользователи класса Sales_data должны сами писать все операции, в которых они нуждаются. В качестве примера напишем новую версию программы из раздела 1.5.2, которая выводила сумму двух транзакций. Программа будет получать на входе такие транзакции:

0-201-78345-X 3 20.00

0-201-78345-X 2 25.00

Каждая транзакция содержит ISBN, количество проданных книг и цену, по которой была продана каждая книга.

Суммирование двух объектов класса Sales_data

Поскольку класс Sales_data не предоставляет операций, придется написать собственный код, осуществляющий ввод, вывод и сложение. Будем подразумевать, что класс Sales_data определен в заголовке Sales_data.h. Определение заголовка рассмотрим в разделе 2.6.3.

Так как эта программа будет длиннее любой, написанной до сих пор, рассмотрим ее по частям. В целом у программы будет следующая структура:

#include

#include

#include "Sales_data.h"

int main() {

 Sales_data data1, data2;

 // код чтения данных в data1 и data2

 // код проверки наличия у data1 и data2 одинакового ISBN

 // если это так, то вывести сумму data1 и data2

}

Как и первоначальная программа, эта начинается с включения заголовков, необходимых для определения переменных, содержащих ввод. Обратите внимание, что, в отличие от версии Sales_item, новая программа включает заголовок string. Он необходим потому, что код должен манипулировать переменной-членом bookNo типа string.

Чтение данных в объект класса Sales_data

Хотя до глав 3 и 10 мы не будем описывать библиотечный тип string подробно, упомянем пока лишь то, что необходимо знать для определения и использования члена класса, содержащего ISBN. Тип string содержит последовательность символов. Он имеет операторы >>, << и == для чтения, записи и сравнения строк соответственно. Этих знаний достаточно для написания кода чтения первой транзакции.

double price = 0; // цена за книгу, используемая для вычисления

                  // общей выручки

// читать первую транзакцию:

//  ISBN, количество проданных книг, цена книги

std::cin >> data1.bookNo >> data1.units_sold >> price;

// вычислить общий доход из price и units_sold

data1.revenue = data1.units_sold * price;

Транзакции содержат цену, по которой была продана каждая книга, но структура данных хранит общий доход. Данные транзакции будем читать в переменную price (цена) типа double, исходя из которой и вычислим член revenue (доход).

std::cin >> data1.bookNo >> data1.units_sold >> price;

Для чтения значений членов bookNo и units_sold (продано экземпляров) объекта по имени data1 оператор ввода использует точечный оператор (см. раздел 1.5.2).

Последний оператор присваивает произведение data1.units_sold и price переменной-члену revenue объекта data1.

Затем программа повторяет тот же код для чтения данных в объект data2.

// читать вторую транзакцию

std::cin >> data2.bookNo >> data2.units_sold >> price;

data2.revenue = data2.units_sold * price;

Вывод суммы двух объектов класса Sales_data

Следующая задача — проверить наличие у транзакций одинакового ISBN. Если это так, вывести их сумму, в противном случае отобразить сообщение об ошибке.

if (data1.bookNo == data2.bookNo) {

 unsigned totalCnt = data1.units_sold + data2.units_sold;

 double totalRevenue = data1.revenue + data2.revenue;

 // вывести: ISBN, общее количество проданных экземпляров,

 // общий доход, среднюю цену за книгу

 std::cout << data1.bookNo << " " << totalCnt

           << " " << totalRevenue << " ";

 if (totalCnt != 0)

  std::cout << totalRevenue/totalCnt << std::endl;

 else

  std::cout << "(no sales)" << std::endl;

 return 0; // означает успех

} else { // транзакции не для того же ISBN

 std::cerr << "Data must refer to the same ISBN"

           << std::endl;

 return -1; // означает неудачу

}

Первый оператор if сравнивает члены bookNo объектов data1 и data2. Если эти члены содержат одинаковый ISBN, выполняется код в фигурных скобках, суммирующий компоненты двух переменных. Поскольку необходимо вывести среднюю цену, сначала вычислим общее количество проданных экземпляров и общий доход, а затем сохраним их в переменных totalCnt и totalRevenue соответственно. Выводим эти значения, а затем проверяем, были ли книги проданы, и если да, то выводим вычисленную среднюю цену за книгу. Если никаких продаж не было, выводим сообщение, обращающее внимание на этот факт.

Упражнения раздела 2.6.2

Упражнение 2.41. Используйте класс Sales_data для перезаписи кода упражнений из разделов 1.5.1, 1.5.2 и 1.6. А также определите свой класс Sales_data в том же файле, что и функция main().

 

2.6.3. Создание собственных файлов заголовка

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

Чтобы гарантировать совпадение определений класса в каждом файле, классы обычно определяют в файлах заголовка. Как правило, классы хранятся в заголовках, имя которых совпадает с именем класса. Например, библиотечный тип string определен в заголовке string. Точно так же, как уже было продемонстрировано, наш класс Sales_data определен в файле заголовка Sales_data.h.

Заголовки (обычно) содержат сущности (такие как определения класса или переменных const и constexpr (см. раздел 2.4), которые могут быть определены в любом файле только однажды. Однако заголовки нередко должны использовать средства из других заголовков. Например, поскольку у класса Sales_data есть член типа string, заголовок Sales_data.h должен включать заголовок string. Как уже упоминалось, программы, использующие класс Sales_data, должны также включать заголовок string, чтобы использовать член bookNo. В результате использующие класс Sales_data программы будут включать заголовок string дважды: один раз непосредственно и один раз как следствие включения заголовка Sales_data.h. Поскольку заголовок мог бы быть включен несколько раз, код необходимо писать так, чтобы обезопасить от многократного включения.

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

Краткое введение в препроцессор

Наиболее распространенный способ обезопасить заголовок от многократного включения подразумевает использование препроцессора. Препроцессор (preprocessor), унаследованный языком С++ от языка С, является программой, которая запускается перед компилятором и изменяет исходный текст программ. Наши программы уже полагаются на такое средство препроцессора, как директива #include. Когда препроцессор встречает директиву #include, он заменяет ее содержимым указанного заголовка.

Программы С++ используют также препроцессор для защиты заголовка (header guard). Защита заголовка полагается на переменные препроцессора (см. раздел 2.3.2). Переменные препроцессора способны находиться в одном из двух состояний: она либо определена, либо не определена. Директива #define получает имя и определяет его как переменную препроцессора. Есть еще две директивы, способные проверить, определена ли данная переменная препроцессора или нет. Директива #ifdef истинна, если переменная была определена, а директива #ifndef истинна, если переменная не была определена. В случае истинности проверки выполняется все, что расположено после директивы #ifdef или #ifndef и до соответствующей директивы #endif.

Эти средства можно использовать для принятия мер против множественного включения следующим образом:

#ifndef SALES_DATA_H

#define SALES_DATA_H

#include

struct Sales_data {

 std::string bookNo;

 unsigned units_sold = 0;

 double revenue = 0.0;

#endif

При первом включении заголовка Sales_data.h директива #ifndef истинна, и препроцессор обработает строки после нее до директивы #endif. В результате переменная препроцессора SALES_DATA_H будет определена, а содержимое заголовка Sales_data.h скопировано в программу. Если впоследствии включить заголовок Sales_data.h в тот же файл, то директива #ifndef окажется ложна и строки между ней и директивой #endif будут проигнорированы.

Имена переменных препроцессора не подчиняются правилам областей видимости языка С++.

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

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

Упражнения раздела 2.6.3

Упражнение 2.42. Напишите собственную версию заголовка Sales_data.h и используйте его для новой версии упражнения из раздела 2.6.2.

 

Строка (string) — это последовательность символов переменной длины. Чтобы использовать тип string, необходимо включить в код заголовок string. Поскольку тип string принадлежит библиотеке, он определен в пространстве имен std. Наши примеры подразумевают наличие следующего кода:

#include

using std::string;

В этом разделе описаны наиболее распространенные операции со строками; а дополнительные операции рассматриваются в разделе 9.5.

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

 

3.2.1. Определение и инициализация строк

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

string s1;          // инициализация по умолчанию; s1 - пустая строка

string s2 = s1;     // s2 - копия s1

string s3 = "hiya"; // s3 - копия строкового литерала

string s4(10, 'c'); // s4 - cccccccccc

Инициализация строки по умолчанию (см. раздел 2.2.1) создает пустую строку; т.е. объект класса string без символов. Когда предоставляется строковый литерал (см. раздел 2.1.3), во вновь созданную строку копируются символы этого литерала, исключая завершающий нулевой символ. При предоставлении количества и символа строка содержит указанное количество экземпляров данного символа.

Таблица 3.1. Способы инициализации объекта класса string

Прямая инициализация и инициализация копией

В разделе 2.2.1 упоминалось, что язык С++ поддерживает несколько разных форм инициализации. Давайте на примере класса string начнем изучать, чем эти формы отличаются друг от друга. Когда переменная инициализируется с использованием знака =, компилятор просят скопировать инициализирующий объект в создаваемый объект, т.е. выполнить инициализацию копией (copy initialization). В противном случае без знака = осуществляется прямая инициализация (direct initialization).

Когда имеется одиночный инициализатор, можно использовать и прямую форму, и инициализацию копией. Но при инициализации переменной несколькими значениями, как при инициализации переменной s4 выше, следует использовать прямую форму инициализации.

string s5 = "hiya"; // инициализация копией

string s6("hiya");  // прямая инициализация

string s7(10, 'c'); // прямая инициализация; s7 - сссссссссс

Если необходимо использовать несколько значений, можно применить косвенную форму инициализации копией при явном создании временного объекта для копирования.

string s8 = string(10, 'c'); // инициализация копией; s8 - сссссссссс

Инициализатор строки s8 — string(10, 'c') — создает строку заданного размера, заполненную указанным символьным значением, а затем копирует ее в строку s8. Это эквивалентно следующему коду:

string temp(10, 'c'); // temp - сссссссссс

string s8 = temp;     // копировать temp в s8

Хотя используемый для инициализации строки s8 код вполне допустим, он менее читабелен и не имеет никаких преимуществ перед способом, которым была инициализирована переменная s7.

 

3.2.2. Операции со строками

Наряду с определением способов создания и инициализации объектов класс определяет также операции, которые можно выполнять с объектами класса. Класс может определить обладающие именем операции, такие как функция isbn() класса Sales_item (см. раздел 1.5.2). Класс также может определить то, что означают различные символы операторов, такие как << или +, когда они применяются к объектам класса. Наиболее распространенные операции класса string приведены в табл. 3.2.

Таблица 3.2. Операции класса string

Чтение и запись строк

Как уже упоминалось в главе 1, для чтения и записи значений встроенных типов, таких как int, double и т.д., используется библиотека iostream. Для чтения и записи строк используются те же операторы ввода и вывода.

// Обратите внимание: перед компиляцией этот код следует дополнить

// директивами #include и объявлениями using

int main() {

 string s;          // пустая строка

 cin >> s;          // чтение разделяемой пробелами строки в s

 cout << s << endl; // запись s в поток вывода

 return 0;

}

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

Таким образом, если ввести " Hello World! " (обратите внимание на предваряющие и завершающие пробелы), фактически будет получено значение "Hello" без пробелов.

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

string s1, s2;

cin >> s1 >> s2; // сначала прочитать в переменную s1,

                 // а затем в переменную s2

cout << s1 << s2 << endl; // отобразить обе строки

Если в этой версии программы осуществить предыдущий ввод, " Hello World! " , выводом будет "HelloWorld!".

Чтение неопределенного количества строк

В разделе 1.4.3 уже рассматривалась программа, читающая неопределенное количество значений типа int. Напишем подобную программу, но читающую строки.

int main() {

 string word;

 while (cin >> word)    // читать до конца файла

  cout << word << endl; // отобразить каждое слово с новой строки

 return 0;

}

Здесь чтение осуществляется в переменную типа string, а не int. Условие оператора while, напротив, выполняется так же, как в предыдущей программе. Условие проверяет поток после завершения чтения. Если поток допустим, т.е. не встретился символ конца файла или недопустимое значение, выполняется тело цикла while. Оно выводит прочитанное значение на стандартное устройство вывода. Как только встречается конец файла (или недопустимый ввод), цикл while завершается.

Применение функции getline() для чтения целой строки

Иногда игнорировать пробелы во вводе не нужно. В таких случаях вместо оператора >> следует использовать функцию getline(). Функция getline() получает поток ввода и строку. Функция читает предоставленный поток до первого символа новой строки и сохраняет прочитанное, исключая символ новой строки, в своем аргументе типа string. Встретив символ новой строки, даже если это первый символ во вводе, функция getline() прекращает чтение и завершает работу. Если символ новой строки во вводе первый, то возвращается пустая строка.

Подобно оператору ввода, функция getline() возвращает свой аргумент типа istream. В результате функцию getline() можно использовать в условии, как и оператор ввода (см. раздел 1.4.3). Например, предыдущую программу, которая выводила по одному слову в строку, можно переписать так, чтобы она вместо этого выводила всю строку:

int main() {

 string line;

 // читать строки до конца файла

 while (getline(cin, line))

  cout << line << endl;

 return 0;

}

Поскольку переменная line не будет содержать символа новой строки, его придется вывести отдельно. Для этого, как обычно, используется манипулятор endl, который, кроме перевода строки, сбрасывает буфер вывода.

Символ новой строки, прекращающий работу функции getline(), отбрасывается и в строковой переменной не сохраняется.

Строковые операции size() и empty()

Функция empty() (пусто) делает то, что и ожидается: она возвращает логическое значение true (раздел 2.1), если строка пуста, и значение false — в противном случае. Подобно функции-члену isbn() класса Sales_item (см. раздел 1.5.2), функция empty() является членом класса string. Для вызова этой функции используем точечный оператор, позволяющий указать объект, функцию empty() которого необходимо вызвать.

А теперь пересмотрим предыдущую программу так, чтобы она выводила только непустые строки:

// читать ввод построчно и отбрасывать пустые строки

while (getline(cin, line))

 if (!line.empty())

  cout << line << endl;

Условие использует оператор логического NOT (оператор !). Он возвращает инверсное значение своего операнда типа bool. В данном случае условие истинно, если строка line не пуста.

Функция size() возвращает длину строки (т.е. количество символов в ней). Давайте используем ее для вывода строк длиной только больше 80 символов.

string line;

// читать ввод построчно и отображать строки длиной более 80 символов

while (getline(cin, line))

 if (line.size() > 80)

  cout << line << endl;

Тип string::size_type

Вполне логично ожидать, что функция size() возвращает значение типа int, а учитывая сказанное в разделе 2.1.1, вероятней всего, типа unsigned. Но вместо этого функция size() возвращает значение типа string::size_type. Этот тип требует более подробных объяснений.

В классе string (и нескольких других библиотечных типах) определены вспомогательные типы данных. Эти вспомогательные типы позволяют использовать библиотечные типы машинно-независимым способом. Тип size_type — это один из таких вспомогательных типов. Чтобы воспользоваться типом size_type, определенным в классе string, применяется оператор области видимости (оператор ::), указывающий на то, что имя size_type определено в классе string.

Хотя точный размер типа string::size_type неизвестен, можно с уверенностью сказать, что этот беззнаковый тип (см. раздел 2.1.1) достаточно большой, чтобы содержать размер любой строки. Любая переменная, используемая для хранения результата операции size() класса string, должна иметь тип string::size_type.

По общему признанию, довольно утомительно вводить каждый раз тип string::size_type. По новому стандарту можно попросить компилятор самостоятельно применить соответствующий тип при помощи спецификаторов auto или decltype (см. раздел 2.5.2):

auto len = line.size(); // len имеет тип string::size_type

Поскольку функция size() возвращает беззнаковый тип, следует напомнить, что выражения, в которых смешаны знаковые и беззнаковые данные, могут дать непредвиденные результаты (см. раздел 2.1.2). Например, если переменная n типа int содержит отрицательное значение, то выражение s.size() < n почти наверняка истинно. Оно возвращает значение true потому, что отрицательное значение переменной n преобразуется в большое беззнаковое значение.

Проблем преобразования между беззнаковыми и знаковыми типами можно избежать, если не использовать переменные типа int в выражениях, где используется функция size().

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

Класс string определяет несколько операторов для сравнения строк. Эти операторы сравнивают строки посимвольно. Результат сравнения зависит от регистра символов, символы в верхнем и нижнем регистре отличаются.

Операторы равенства (== и !=) проверяют, равны или не равны две строки соответственно. Две строки равны, если у них одинаковая длина и одинаковые символы. Операторы сравнения (<, >, <=, >=) проверяют, меньше ли одна строка другой, больше, меньше или равна, больше или равна другой. Эти операторы используют ту же стратегию, старшинство символов в алфавитном порядке в зависимости от регистра.

1. Если длина у двух строк разная и если каждый символ более короткой строки совпадает с соответствующим символом более длинной, то короткая строка меньше длинной.

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

Для примера рассмотрим следующие строки:

string str = "Hello";

string phrase = "Hello World";

string slang = "Hiya";

Согласно правилу 1 строка str меньше строки phrase. Согласно правилу 2 строка slang больше, чем строки str и phrase.

Присвоение строк

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

string st1(10, 'c'), st2; // st1 - сссссссссс; st2 - пустая строка

st1 = st2; // присвоение: замена содержимого st1 копией st2

           // теперь st1 и st2 - пустые строки

Сложение двух строк

Результатом сложения двух строк является новая строка, объединяющая содержимое левого операнда, а затем правого. Таким образом, при применении оператора суммы (оператор +) к строкам результатом будет новая строка, символы которой являются копией символов левого операнда, сопровождаемые символами правого операнда. Составной оператор присвоения (оператор +=) (см. раздел 1.4.1) добавляет правый операнд к строке слева:

string s1 = "hello, ", s2 = "world\n";

string s3 = s1 + s2; // s3 - hello, world\n

s1 += s2;            // эквивалентно s1 = s1 + s2

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

Как уже упоминалось в разделе 2.1.2, один тип можно использовать там, где ожидается другой тип, если есть преобразование из данного типа в ожидаемый. Библиотека string позволяет преобразовывать как символьные, так и строковые литералы (см. раздел 2.1.3) в строки. Поскольку эти литералы можно использовать там, где ожидаются строки, предыдущую программу можно переписать следующим образом:

string s1 = "hello", s2 = "world"; // в s1 и s2 нет пунктуации

string s3 = s1 + ", " + s2 + '\n';

Когда объекты класса string смешиваются со строковыми или символьными литералами, то по крайней мере один из операндов каждого оператора + должен иметь тип string.

string s4 = s1 + ", ";           // ok: сложение строки и литерала

string s5 = "hello" + ", ";      // ошибка: нет строкового операнда

string s6 = s1 + ", " + "world"; // ok: каждый + имеет

                                 //  строковый операнд

string s7 = "hello" + ", " + s2; // ошибка: нельзя сложить строковые

                                 // литералы

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

string s6 = (s1 + ", ") + "world";

Часть s1 + ", " выражения возвращает объект класса string, она составляет левый операнд второго оператора +. Это эквивалентно следующему коду:

string tmp = s1 + ", "; // ok: + имеет строковый операнд

s6 = tmp + "world";     // ok: + имеет строковый операнд

С другой стороны, инициализация переменной s7 недопустима, и это становится очевидным, если заключить часть выражения в скобки:

string s7 = ("hello" + ", ") + s2; // ошибка: нельзя сложить строковые

                                   // литералы

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

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

Упражнения раздела 3.2.2

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

Упражнение 3.3. Объясните, как символы пробелов обрабатываются в операторе ввода класса string и в функции getline().

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

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

 

3.2.3. Работа с символами строки

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

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

Другой частью обработки символов является выяснение и (или) изменение их характеристик. Эта часть задачи выполняется набором библиотечных функций, описанных в табл. 3.3. Данные функции определены в заголовке cctype.

Таблица 3.3. Функции cctype

Совет. Используйте версии С++ библиотечных заголовков языка С

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

Следовательно, у заголовка cctype то же содержимое, что и у заголовка ctype.h , но в форме, соответствующей программе С++. В частности, имена, определенные в заголовках с имя, определены также в пространстве имен std , тогда как имена, определенные в заголовках .h , — нет.

Как правило, в программах на языке С++ используют заголовки версии c имя , а не имя .h . Таким образом, имена из стандартной библиотеки будут быстро найдены в пространстве имен std . Использование заголовка .h возлагает на программиста дополнительную заботу по отслеживанию, какие из библиотечных имен унаследованы от языка С, а какие принадлежат языку С++.

Обработка каждого символа, использование серийного оператора for

Если необходимо сделать нечто с каждым символом в строке, то наилучшим подходом является использование оператора, введенного новым стандартом, — серийный оператор for (range for). Этот оператор перебирает элементы данной ему последовательности и выполняет с каждым из них некую операцию. Его синтаксическая форма такова:

for ( объявление : выражение )

  оператор

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

Строка представляет собой последовательность символов, поэтому объект типа string можно использовать как выражение в серийном операторе for. Например, серийный оператор for можно использовать для вывода каждого символа строки в отдельной строке вывода.

string str("some string");

// вывести символы строки str по одному на строку

for (auto с : str)  // для каждого символа в строке str

 cout << с << endl; // вывести текущий символ и символ новой строки

Цикл for ассоциирует переменную с с переменной str типа string. Управляющая переменная цикла определяется тем же способом, что и любая другая переменная. В данном случае используется спецификатор auto (см. раздел 2.5.2), чтобы позволить компилятору самостоятельно определять тип переменной с, которым в данном случае будет тип char. На каждой итерации следующий символ строки str будет скопирован в переменную с. Таким образом, можно прочитать этот цикл так: "Для каждого символа с в строке str" сделать нечто. Под "нечто" в данном случае подразумевается вывод текущего символа, сопровождаемого символом новой строки.

Рассмотрим более сложный пример и используем серийный оператор for, а также функцию ispunct() для подсчета количества знаков пунктуации в строке:

string s("Hello World!!!");

// punct_cnt имеет тот же тип, что и у возвращаемого значения

// функции s.size(); см. p. 2.5.3

decltype(s.size()) punct_cnt = 0;

// подсчитать количество знаков пунктуации в строке s

for (auto с : s) // для каждого символа в строке s

 if (ispunct(c)) // если символ знак пунктуации

   ++punct_cnt;  // увеличить счетчик пунктуаций

cout << punct_cnt

     << " punctuation characters in " << s << endl;

Вывод этой программы таков:

3 punctuation characters in Hello World!!!

Здесь для объявления счетчика punct_cnt используется спецификатор decltype (см. раздел 2.5.3). Его тип совпадает с типом возвращаемого значения функции s.size(), которым является тип string::size_type. Для обработки каждого символа в строке используем серийный оператор for. На сей раз проверяется, является ли каждый символ знаком пунктуации. Если да, то используем оператор инкремента (см. раздел 1.4.1) для добавления единицы к счетчику. Когда серийный оператор for завершает работу, отображается результат.

Использование серийного оператора for для изменения символов в строке

Если необходимо изменить значение символов в строке, переменную цикла следует определить как ссылочный тип (см. раздел 2.3.1). Помните, что ссылка — это только другое имя для данного объекта. При использовании ссылки в качестве управляющей переменной она будет по очереди связана с каждым элементом последовательности. Используя ссылку, можно изменить символ, с которым она связана.

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

string s("Hello World!!!");

// преобразовать s в верхний регистр

for (auto &с : s) // для каждого символа в строке s

                  // (примечание: с - ссылка)

 с = toupper(с);  // с - ссылка, поэтому присвоение изменяет

                  // символ в строке s

cout << s << endl;

Вывод этого кода таков:

HELLO WORLD!!!

На каждой итерации переменная с ссылается на следующий символ строки s. При присвоении значения переменной с изменяется соответствующий символ в строке s.

с = toupper(с); // с - ссылка, поэтому присвоение изменяет

                // символ в строке s

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

Обработка лишь некоторых символов

Серийный оператор for работает хорошо, когда необходимо обработать каждый символ. Но иногда необходим доступ только к одному символу или к некоторому количеству символов на основании некоего условия. Например, можно преобразовать в верхний регистр только первый символ строки или только первое слово в строке.

Существуют два способа доступа к отдельным символам в строке: можно использовать индексирование или итератор. Более подробная информация об итераторах приведена в разделе 3.4 и в главе 9.

Оператор индексирования (оператор []) получает значение типа string::size_type (раздел 3.2.2), обозначающее позицию символа, к которому необходим доступ. Оператор возвращает ссылку на символ в указанной позиции.

Индексация строк начинается с нуля; если строка s содержит по крайней мере два символа, то первым будет символ s[0], вторым — s[1]На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .
, а последним символом является s[s.size() - 1].

Значения, используемые для индексирования строк, не должны быть отрицательными и не должны превосходить размер строки (>= 0 и < size()). Результат использования индекса вне этого диапазона непредсказуем. Непредсказуема также индексация пустой строки.

Значение оператора индексирования называется индексом (index). Индекс может быть любым выражением, возвращающим целочисленное значение. Если у индекса будет знаковый тип, то его значение преобразуется в беззнаковый тип size_type (см. раздел 2.1.2).

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

if (!s.empty())        // удостоверившись, что символ для вывода есть,

 cout << s[0] << endl; // вывести первый символ строки s

Прежде чем обратиться к символу, удостоверимся, что строка s не пуста. При каждом использовании индексирования следует проверять наличие значения в данной области. Если строка s пуста, то значение s[0] неопределенно.

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

string s("some string");

if (!s.empty())        // удостовериться в наличии символа s[0]

 s[0] = toupper(s[0]); // присвоить новое значение первому символу

Вывод этой программы приведен ниже.

Some string

Использование индексирования для перебора

В следующем примере переведем в верхний регистр первое слово строки s:

// обрабатывать символы строки s, пока они не исчерпаются или

// не встретится пробел

for (decltype(s.size()) index = 0;

 index != s.size() && !isspace(s[index]); ++index)

 s[index] = toupper(s[index]); // преобразовать в верхний регистр

Вывод этой программы таков:

SOME string

Цикл for (см. раздел 1.4.2) использует переменную index для индексирования строки s. Для присвоения переменной index соответствующего типа используется спецификатор decltype. Переменную index инициализируем значением 0, чтобы первая итерация началась с первого символа строки s. На каждой итерации значение переменной index увеличивается, чтобы получить следующий символ строки s. В теле цикла текущий символ переводится в верхний регистр.

В условии цикла for используется новая часть — оператор логического AND (оператор &&). Этот оператор возвращает значение true, если оба операнда истинны, и значение false в противном случае. Важно то, что этот оператор гарантирует обработку своего правого операнда, только если левый операнд истинен. В данном случае это гарантирует, что индексирования строки s не будет, если переменная index находится вне диапазона. Таким образом, часть s[index] выполняется, только если переменная index не равна s.size(). Поскольку инкремент переменной index никогда не превзойдет значения s.size(), переменная index всегда будет меньше s.size().

Внимание! Индексирование не контролируется

При использовании индексирования следует самому позаботиться о том, чтобы индекс оставался в допустимом диапазоне. Индекс должен быть >= 0 и < size() строки. Для упрощения кода, использующего индексирование, в качестве индекса всегда следует использовать переменную типа string::size_type . Поскольку это беззнаковый тип, индекс не может быть меньше нуля. При использовании значения типа size_type в качестве индекса достаточно проверять только то, что значение индекса меньше значения, возвращаемого функцией size() .

#_.jpg Библиотека не обязана проверять и не проверяет значение индекса. Результат использования индекса вне диапазона непредсказуем.

Использование индексирования для произвольного доступа

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

Предположим, например, что имеется число от 0 до 15, которое необходимо представить в шестнадцатеричном виде. Для этого можно использовать строку, инициализированную шестнадцатью шестнадцатеричными цифрами.

const string hexdigits = "0123456789ABCDEF"; // возможные

                                             // шестнадцатеричные цифры

cout << "Enter a series of numbers between 0 and 15"

     << " separated by spaces. Hit ENTER when finished: "

     << endl;

string result;       // будет содержать результирующую

                     // шестнадцатеричную строку

string::size_type n; // содержит введенное число

while (cin >> n)

 if (n < hexdigits.size()) // игнорировать недопустимый ввод

  result += hexdigits[n];  // выбрать указанную

                           // шестнадцатеричную цифру

cout << "Your hex number is: " << result << endl;

Если ввести следующие числа:

12 0 5 15 8 15

то результат будет таким:

Your hex number is: C05F8F

Программа начинается с инициализации строки hexdigits, содержащей шестнадцатеричные цифры от 0 до F. Сделаем эту строку константной (см. раздел 2.4), поскольку содержащиеся в ней значения не должны изменяться. Для индексирования строки hexdigits используем в цикле введенное значение n. Значением hexdigits[n] является символ, расположенный в позиции n строки hexdigits. Например, если n равно 15, то результат — F; если 12, то результат — С и т.д. Полученная цифра добавляется к переменной result, которая и выводится, когда весь ввод прочитан.

Всякий раз, когда используется индексирование, следует позаботиться о том, чтобы индекс оставался в диапазоне. В этой программе индекс, n, имеет тип string::size_type, который, как известно, является беззнаковым. В результате значение переменной n гарантированно будет больше или равно 0. Прежде чем использовать переменную n для индексирования строки hexdigits, удостоверимся, что ее значение меньше, чем hexdigits.size().

Упражнения раздела 3.2.3

Упражнение 3.6. Используйте серийный оператор for для замены всех символов строки на X.

Упражнение 3.7. Что будет, если определить управляющую переменную цикла в предыдущем упражнении как имеющую тип char? Предскажите результат, а затем измените программу так, чтобы использовался тип char, и убедитесь в своей правоте.

Упражнение 3.8. Перепишите программу первого упражнения, сначала используя оператор while, а затем традиционный цикл for. Какой из этих трех подходов вы предпочтете и почему?

Упражнение 3.9. Что делает следующая программа? Действительно ли она корректна? Если нет, то почему?

string s;

cout << s[0] << endl;

Упражнение 3.10. Напишите программу, которая читает строку символов, включающую знаки пунктуации, и выведите ее, но уже без знаков пунктуации.

Упражнение 3.11. Допустим ли следующий серийный оператор for? Если да, то каков тип переменной с?

const string s = "Keep out!";

for (auto &c : s) {/*...*/}

 

Вектор (vector) — это коллекция объектов одинакового типа, каждому из которых присвоен целочисленный индекс, предоставляющий доступ к этому объекту. Вектор — это контейнер (container), поскольку он "содержит" другие объекты. Более подробная информация о контейнерах приведена в части II.

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

#include

using std::vector;

Типvector — это шаблон класса (class template). Язык С++ поддерживают шаблоны и классов, и функций. Написание шаблона требует довольно глубокого понимания языка С++. До главы 16 мы даже не будем рассматривать создание собственных шаблонов! К счастью, чтобы использовать шаблоны, вовсе не обязательно уметь их создавать.

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

Для создания экземпляра шаблона класса следует указать дополнительную информацию, характер которой зависит от шаблона. Эта информация всегда задается одинаково: в угловых скобках после имени шаблона.

В случае вектора предоставляемой дополнительной информацией является тип объектов, которые он должен содержать:

vector ivec;             // ivec содержит объекты типа int

vector Sales_vec; // содержит объекты класса Sales_item

vector> file;  // вектор, содержащий другие векторы

В этом примере компилятор создает три разных экземпляра шаблона vector: vector, vector и vector>.

vector — это шаблон, а не класс. Классам, созданным по шаблону vector, следует указать тип хранимого элемента, например vector.

Можно определить векторы для содержания объектов практически любого типа. Поскольку ссылки не объекты (см. раздел 2.3.1), не может быть вектора ссылок. Однако векторы большинства других (не ссылочных) встроенных типов и типов классов вполне могут существовать. В частности, может быть вектор, элементами которого являются другие векторы.

Следует заметить, что прежние версии языка С++ использовали несколько иной синтаксис определения вектора, элементы которого сами являлись экземплярами шаблона vector (или другого типа шаблона). Прежде необходимо было ставить пробел между закрывающей угловой скобкой внешней части vector и типом его элемента: т.е. vector >, а не vector>.

Некоторые компиляторы могут потребовать объявления вектора векторов в старом стиле, например vector >.

 

3.3.1. Определение и инициализация векторов

Подобно любому типу класса, шаблон vector контролирует способ определения и инициализации векторов. Наиболее распространенные способы определения векторов приведены в табл. 3.4.

Инициализация вектора по умолчанию (см. раздел 2.2.1) позволяет создать пустой вектор определенного типа:

vector svec; // инициализация по умолчанию;

                     //  у svec нет элементов

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

Таблица 3.4. Способы инициализации векторов

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

vector ivec; // первоначально пустой

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

vector ivec2(ivec);    // копировать элементы ivec в ivec2

vector ivec3 = ivec;   // копировать элементы ivec в ivec3

vector svec(ivec2); // svec содержит строки,

                            // а не целые числа

Списочная инициализация вектора

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

vector articles = {"a", "an", "the"};

В результате у вектора будет три элемента: первый со значением "а", второй — "an", последний — "the".

Как уже упоминалось, язык С++ предоставляет несколько форм инициализации (см. раздел 2.2.1). Во многих, но не во всех случаях эти формы инициализации можно использовать взаимозаменяемо. На настоящий момент приводились примеры двух форм инициализации: инициализация копией (с использованием знака =) (см. раздел 3.2.1), когда предоставляется только один инициализатор; и внутриклассовая инициализация (см. раздел 2.6.1). Третий способ подразумевает предоставление списка значений элементов, заключенных в фигурные скобки (списочная инициализация). Нельзя предоставить список инициализаторов, используя круглые скобки.

vector v1{"a", "an", "the"}; // списочная инициализация

vector v2("a", "an", "the"); // ошибка

Создание определенного количества элементов

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

vector ivec(10, -1);       // десять элементов типа int, каждый из

                                // которых инициализирован значением -1

vector svec(10, "hi!"); // десять строк, инициализированных

                                // значением "hi!"

Инициализация значения

Иногда инициализирующее значение можно пропустить и указать только размер. В этом случае произойдет инициализация значения (value initialization), т.е. библиотека создаст инициализатор элемента сама. Это созданное библиотекой значение используется для инициализации каждого элемента в контейнере. Значение инициализатора элемента вектора зависит от типа его элементов.

Если вектор хранит элементы встроенного типа, такие как int, то инициализатором элемента будет значение 0. Если элементы имеют тип класса, такой как string, то инициализатором элемента будет его значение по умолчанию.

vector ivec(10);    // десять элементов, инициализированных

                         // значением 0

vector svec(10); // десять элементов, инициализированных

                         // пустой строкой

Эта форма инициализации имеет два ограничения. Первое — некоторые классы всегда требуют явного предоставления инициализатора (см. раздел 2.2.1). Если вектор содержит объекты, тип которых не имеет значения по умолчанию, то начальное значение элемента следует предоставить самому; невозможно создать векторы таких типов, предоставив только размер.

Второе ограничение заключается в том, что при предоставлении количества элементов без исходного значения необходимо использовать прямую инициализацию (direct initialization):

vector vi = 10; // ошибка: необходима прямая инициализация

Здесь число 10 используется для указания на то, как создать вектор, — необходимо, чтобы он обладал десятью элементами с инициализированными значениями. Число 10 не "копируется" в вектор. Следовательно, нельзя использовать форму инициализации копией. Более подробная информация об этом ограничении приведена в разделе 7.5.4.

#magnify.png Списочный инициализатор или количество элементов

В некоторых случаях смысл инициализации зависит от того, используются ли при передаче инициализаторов фигурные скобки или круглые. Например, при инициализации вектора vector одиночным целочисленным значением это значение могло бы означать либо размер вектора, либо значение элемента. Точно так же, если предоставить два целочисленных значения, то они могли бы быть размером и исходным значением или значениями для двух элементов вектора. Для определения предназначения используются фигурные или круглые скобки.

vector v1(10);    // v1 имеет десять элементов со значением 0

vector v2{10};    // v2 имеет один элемент со значением 10

vector v3(10, 1); // v3 имеет десять элементов со значением 1

vector v4{10, 1}; // v4 имеет два элемента со значениями 10 и 1

Круглые скобки позволяют сообщить, что предоставленные значения должны использоваться для создания объекта. Таким образом, векторы v1 и v3 используют свои инициализаторы для определения размера вектора, а также размера и значения его элементов соответственно.

Использование фигурных скобок, {...}, означает попытку списочной инициализации. Таким образом, если класс способен использовать значения в фигурных скобках как список инициализаторов элементов, то он так и сделает. Если это невозможно, то следует рассмотреть другие способы инициализации объектов. Значения, предоставленные при инициализации векторов v2 и v4, рассматриваются как значения элементов. Это списочная инициализация объектов; у полученных векторов будет один и два элемента соответственно.

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

vector v5{"hi"}; // списочная инициализация: v5 имеет

                         // один элемент

vector v6("hi"); // ошибка: нельзя создать вектор из

                         // строкового литерала

vector v7{10}; // v7 имеет десять элементов, инициализированных

                       // значением по умолчанию

vector v8{10, "hi"}; // v8 имеет десять элементов со

                             // значением "hi"

Хотя фигурные скобки использованы во всех этих определениях, кроме одного, только вектор v5 имеет списочную инициализацию. Для списочной инициализации вектора значения в фигурных скобках должны соответствовать типу элемента. Нельзя использовать объект типа int для инициализации строки, поэтому инициализаторы векторов v1 и v8 не могут быть инициализаторами элементов. Если списочная инициализация невозможна, компилятор ищет другие способы инициализации объектов.

Упражнения раздела 3.3.1

Упражнение 3.12. Есть ли ошибки в следующих определениях векторов?

Объясните, что делают допустимые определения. Объясните, почему некорректны недопустимые определения.

(a) vector> ivec;

(b) vector svec = ivec;

(c) vector svec(10, "null");

Упражнение 3.13. Сколько элементов находится в каждом из следующих векторов? Каковы значения этих элементов?

(a) vector v1;         (b) vector v2 (10);

(с) vector v3(10, 42); (d) vector v4{10};

(e) vector v5{10, 42}; (f) vector v6{10};

(g) vector v7{10, "hi"};

 

3.3.2. Добавление элементов в вектор

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

Если необходим вектор со значениями от 0 до 9, то можно легко использовать списочную инициализацию. Но что если необходимы элементы от 0 до 99 или от 0 до 999? Списочная инициализация была бы слишком громоздкой. В таких случаях лучше создать пустой вектор и использовать его функцию-член push_back(), чтобы добавить элементы во время выполнения. Функция push_back() вставляет переданное ей значение в вектор как новый последний элемент. Рассмотрим пример.

vector v2; // пустой вектор

for (int i = 0; i != 100; ++i)

 v2.push_back(i); // добавить последовательность целых чисел в v2

// по завершении цикла v2 имеет 100 элементов со значениями от 0 до 99

Хотя заранее известно, что будет 100 элементов, вектор v2 определяется как пустой. Каждая итерация добавляет следующее по порядку целое число в вектор v2 как новый элемент.

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

// читать слова со стандартного устройства ввода и сохранять их

// в векторе как элементы

string word;

vector text; // пустой вектор

while (cin >> word) {

 text.push_back(word); // добавить слово в текст

}

И снова все начинается с пустого вектора. На сей раз, неизвестное количество значений читается и сохраняется в векторе строк text.

Ключевая концепция. Рост вектора эффективен

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

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

Последствия возможности добавления элементов в вектор

Тот факт, что добавление элементов в вектор весьма эффективно, существенно упрощает многие задачи программирования. Но эта простота налагает новые обязательства на наши программы: необходимо гарантировать корректность всех циклов, даже если цикл изменяет размер вектора.

Другое последствие динамического характера векторов станет яснее, когда мы узнаем больше об их использовании. Но есть одно последствие, на которое стоит обратить внимание уже сейчас: по причинам, изложенным в разделе 5.4.3, нельзя использовать серийный оператор for, если тело цикла добавляет элементы в вектор.

Тело серийного оператора for не должно изменять размер перебираемой последовательности.

Упражнения раздела 3.3.2

Упражнение 3.14. Напишите программу, читающую последовательность целых чисел из потока cin и сохраняющую их в векторе.

Упражнение 3.15. Повторите предыдущую программу, но на сей раз читайте строки.

 

3.3.3. Другие операции с векторами

Кроме функции push_back(), шаблон vector предоставляет еще несколько операций, большинство из которых подобно соответствующим операциям класса string. Наиболее важные из них приведены в табл. 3.5.

Таблица 3.5. Операции с векторами

Доступ к элементам вектора осуществляется таким же способом, как и к символам строки: по их позиции в векторе. Например, для обработки все элементов вектора можно использовать серийный оператор for (раздел 3.2.3).

vector v{1,2,3,4,5,6,7,8,9};

for (auto &i : v)  // для каждого элемента вектора v

                   // (обратите внимание: i - ссылка)

 i *= i;           // квадрат значения элемента

for (auto i : v)   // для каждого элемента вектора v

 cout << i << " "; // вывод элемента

cout << endl;

В первом цикле управляющая переменная i определяется как ссылка, чтобы использовать ее для присвоения новых значений элементам вектора v. Используя спецификатор auto, позволим вывести ее тип автоматически. Этот цикл использует новую форму составного оператора присвоения (раздел 1.4.1). Как известно, оператор += добавляет правый операнд к левому и сохраняет результат в левом операнде. Оператор *= ведет себя точно так же, но перемножает левый и правый операнды, сохраняя результат в левом операнде. Второй серийный оператор for отображает каждый элемент.

Функции-члены empty() и size() вектора ведут себя так же, как и соответствующие функции класса string (раздел 3.2.2): функция empty() возвращает логическое значение, указывающее, содержит ли вектор какие-нибудь элементы, а функция size() возвращает их количество. Функция-член size() возвращает значение типа size_type, определенное соответствующим типом шаблона vector.

Чтобы использовать тип size_type, необходимо указать тип, для которого он определен. Для типа vector всегда необходимо указывать тип хранимого элемента (раздел 3.3).

vector::size_type // ok

vector::size_type      // ошибка

Операторы равенства и сравнения вектора ведут себя как соответствующие операторы класса string (раздел 3.2.2). Два вектора равны, если у них одинаковое количество элементов и значения соответствующих элементов совпадают. Операторы сравнения полагаются на алфавитный порядок: если у векторов разные размеры, но соответствующие элементы равны, то вектор с меньшим количеством элементов меньше вектора с большим количеством элементов. Если у элементов векторов разные значения, то их отношения определяются по первым отличающимся элементам.

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

Вычисление индекса вектора

Используя оператор индексирования (раздел 3.2.3), можно выбрать указанный элемент. Подобно строкам, индексирование вектора начинаются с 0; индекс имеет тип size_type соответствующего типа; и если вектор не константен, то в возвращенный оператором индексирования элемент можно осуществить запись. Кроме того, как было продемонстрировано в разделе 3.2.3, можно вычислить индекс и непосредственно обратиться к элементу в данной позиции.

Предположим, имеется набор оценок степеней в диапазоне от 0 до 100. Необходимо рассчитать, сколько оценок попадает в кластер по 10. Между нулем и 100 возможна 101 оценка. Эти оценки могут быть представлены 11 кластерами: 10 кластеров по 10 оценок каждый плюс один кластер для наивысшей оценки 100. Первый кластер подсчитывает оценки от 0 до 9, второй — от 10 до 19 и т.д. Заключительный кластер подсчитывает количество оценок 100.

Таким образом, если введены следующие оценки:

42 65 95 100 39 67 95 76 88 76 83 92 76 93

результат их кластеризации должен быть таким:

0 0 0 1 1 0 2 3 2 4 1

Он означает, что не было никаких оценок ниже 30, одна оценка в 30-х, одна в 40-х, ни одной в 50-х, две в 60-х, три в 70-х, две в 80-х, четыре в 90-х и одна оценка 100.

Используем для содержания счетчиков каждого кластера вектор с 11 элементами. Индекс кластера для данной оценки можно определить делением этой оценки на 10. При делении двух целых чисел получается целое число, дробная часть которого усекается. Например, 42/10=4, 65/10=6, а 100/10=10.

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

// подсчет количества оценок в кластере по десять: 0--9,

// 10--19, ... 90--99, 100

vector scores(11, 0); // 11 ячеек, все со значением 0

unsigned grade;

while (cin >> grade) { // читать оценки

 if (grade <= 100)     // обрабатывать только допустимые оценки

   ++scores[grade/10]; // приращение счетчика текущего кластера

Код начинается с определения вектора для хранения счетчиков кластеров. В данном случае все элементы должны иметь одинаковое значение, поэтому резервируем 11 элементов, каждый из которых инициализируем значением 0. Условие цикла while читает оценки. В цикле проверяется допустимость значения прочитанной оценки (т.е. оно меньше или равно 100). Если оценка допустима, то увеличиваем соответствующий счетчик.

Оператор, осуществляющий приращение, является хорошим примером краткости кода С++:

++scores[grade/10]; // приращение счетчика текущего кластера

Это выражение эквивалентно следующему:

auto ind = grade/10;           // получить индекс ячейки

scores[ind] = scores[ind] + 1; // приращение счетчика

Индекс ячейки вычисляется делением значения переменной grade на 10. Полученный результат используется для индексирования вектора scores, что обеспечивает доступ к соответствующему счетчику для этой оценки. Увеличение значения этого элемента означает принадлежность текущей оценки данному диапазону.

Как уже упоминалось, при использовании индексирования следует позаботиться о том, чтобы индексы оставались в диапазоне допустимых значений (см. раздел 3.2.3). В этой программе проверка допустимости подразумевает принадлежность оценки к диапазону 0-100. Таким образом, можно использовать индексы от 0 до 10. Они расположены в пределах от 0 до scores.size() - 1.

Индексация не добавляет элементов

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

vector ivec; // пустой вектор

for (decltype(ivec.size()) ix = 0; ix != 10; ++ix)

 ivec[ix] = ix;   // катастрофа: ivec не имеет элементов

Причина ошибки — вектор ivec пуст; в нем нет никаких элементов для индексирования! Как уже упоминалось, правильный цикл использовал бы функцию push_back():

for (decltype(ivec.size()) ix = 0; ix != 10; ++ix)

 ivec.push_back(ix); // ok: добавляет новый элемент со значением ix

Оператор индексирования вектора (и строки) лишь выбирает существующий элемент; он не может добавить новый элемент.

Внимание! Индексировать можно лишь существующие элементы!

Очень важно понять, что оператор индексирования ( [] ) можно использовать для доступа только к фактически существующим элементам. Рассмотрим пример.

vector<int> ivec;      // пустой вектор

cout << ivec[0];       // ошибка: ivec не имеет элементов!

vector<int> ivec2(10); // вектор из 10 элементов

cout << ivec2[10];     // ошибка: ivec2 имеет элементы 0...9

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

Попытка индексирования несуществующих элементов, к сожалению, является весьма распространенной и грубой ошибкой программирования. Так называемая ошибка переполнения буфера (buffer overflow) — результат индексирования несуществующих элементов. Такие ошибки являются наиболее распространенной причиной проблем защиты приложений.

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

Упражнения раздела 3.3.3

Упражнение 3.16. Напишите программу, выводящую размер и содержимое вектора из упражнения 3.13. Проверьте правильность своих ответов на это упражнение. При неправильных ответах повторно изучите раздел 3.3.1.

Упражнение 3.17. Прочитайте последовательность слов из потока cin и сохраните их в векторе. Прочитав все слова, обработайте вектор и переведите символы каждого слова в верхний регистр. Отобразите преобразованные элементы по восемь слов на строку.

Упражнение 3.18. Корректна ли следующая программа? Если нет, то как ее исправить?

vector ivec;

ivec[0] = 42;

Упражнение 3.19. Укажите три способа определения вектора и заполнения его десятью элементами со значением 42. Укажите, есть ли предпочтительный способ для этого и почему.

Упражнение 3.20. Прочитайте набор целых чисел в вектор. Отобразите сумму каждой пары соседних элементов. Измените программу так, чтобы она отображала сумму первого и последнего элементов, затем сумму второго и предпоследнего и т.д.

 

Хотя для доступа к символам строки или элементам вектора можно использовать индексирование, для этого существует и более общий механизм — итераторы (iterator). Как будет продемонстрировано в части II, кроме векторов библиотека предоставляет несколько других видов контейнеров. У всех библиотечных контейнеров есть итераторы, но только некоторые из них поддерживают оператор индексирования. С технической точки зрения тип string не является контейнерным, но он поддерживает большинство контейнерных операций. Как уже упоминалось, и строки, и векторы предоставляют оператор индексирования. У них также есть итераторы.

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

 

3.4.1. Использование итераторов

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

// типы b и е определяют компилятор; см. раздел 2.5.2

// b обозначает первый элемент контейнера v, а е - элемент

// после последнего

auto b = v.begin(), е = v.end();

// b и е имеют одинаковый тип

Итератор, возвращенный функцией end(), указывает на следующую позицию за концом контейнера (или строки). Этот итератор обозначает несуществующий элемент за концом контейнера. Он используется как индикатор, означающий, что обработаны все элементы. Итератор, возвращенный функцией end(), называют итератором после конца (off-the-end iterator), или сокращенно итератором end. Если контейнер пуст, функция begin() возвращает тот же итератор, что и функция end(). 

Если контейнер пуст, возвращаемые функциями begin() и end() итераторы совпадают и, оба являются итератором после конца.

Обычно точный тип, который имеет итератор, неизвестен (да и не нужен). В этом примере при определении итераторов b и е использовался спецификатор auto (см. раздел 2.5.2). В результате тип этих переменных будет совпадать с возвращаемыми функциями-членами begin() и end() соответственно. Не будем пока распространяться об этих типах.

Операции с итераторами

Итераторы поддерживают лишь несколько операций, которые перечислены в табл. 3.6. Два допустимых итератора можно сравнить при помощи операторов == и !=. Итераторы равны, если они указывают на тот же элемент или если оба они указывают на позицию после конца того же контейнера. В противном случае они не равны.

Таблица 3.6. Стандартные операции с итераторами контейнера

Подобно указателям, к значению итератора можно обратиться, чтобы получить элемент, на который он ссылается. Кроме того, подобно указателям, можно обратиться к значению только допустимого итератора, который обозначает некий элемент (см. раздел 2.3.2). Результат обращения к значению недопустимого итератора или итератора после конца непредсказуем.

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

string s("some string");

if (s.begin() != s.end()) { // удостовериться, что строка s не пуста

 auto it = s.begin();       // it указывает на первый символ строки s

 *it = toupper(*it);        // текущий символ в верхний регистр

}

Как и в первоначальной программе, сначала удостоверимся, что строка s не пуста. В данном случае для этого сравниваются итераторы, возвращенные функциями begin() и end(). Эти итераторы равны, если строка пуста. Если они не равны, то в строке s есть по крайней мере один символ.

В теле оператора if функция begin() возвращает итератор на первый символ, который присваивается переменной it. Обращение к значению этого итератора и передача его функции toupper() позволяет перевести данный символ в верхний регистр. Кроме того, обращение к значению итератора it слева от оператора присвоения позволяет присвоить символ, возвращенный функцией toupper(), первому символу строки s. Как и в первоначальной программе, вывод будет таким:

Some string

Перемещение итератора с одного элемента на другой

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

Поскольку итератор, возвращенный функцией end(), не указывает на элемент, он не допускает ни приращения, ни обращения к значению.

Перепишем программу, изменяющую регистр первого слова в строке, с использованием итератора.

// обрабатывать символы, пока они не исчерпаются,

//  или не встретится пробел

for (auto it = s.begin(); it != s.end() && !isspace(*it); ++it)

 *it = toupper(*it); // преобразовать в верхний регистр

Этот цикл, подобно таковому в разделе 3.2.3, перебирает символы строки s, останавливаясь, когда встречается пробел. Но данный цикл использует для этого итератор, а не индексирование.

Цикл начинается с инициализации итератора it результатом вызова функции s.begin(), чтобы он указывал на первый символ строки s (если он есть). Условие проверяет, не достиг ли итератор it конца строки (s.end()). Если это не так, то проверяется следующее условие, где обращение к значению итератора it, возвращающее текущий символ, передается функции isspace(), чтобы выяснить, не пробел ли это. В конце каждой итерации выполняется оператор ++it, чтобы переместить итератор на следующий символ строки s.

У этого цикла то же тело, что и у последнего оператора if предыдущей программы. Обращение к значению итератора it используется и для передачи текущего символа функции toupper(), и для присвоения полученного результата символу, на который указывает итератор it.

Ключевая концепция. Обобщенное программирование

Программисты, перешедшие на язык С++ с языка С или Java, могли бы быть удивлены тем, что в данном цикле for был использован оператор != , а не < . Программисты С++ используют оператор != исключительно по привычке. По этой же причине они используют итераторы, а не индексирование: этот стиль программирования одинаково хорошо применим к контейнерам различных видов, предоставляемых библиотекой.

Как уже упоминалось, только у некоторых библиотечных типов, vector и string , есть оператор индексирования. Тем не менее у всех библиотечных контейнеров есть итераторы, для которых определены операторы == и != . Однако большинство их итераторов не имеют оператора < . При обычном использовании итераторов и оператора != можно не заботиться о точном типе обрабатываемого контейнера.

Типы итераторов

Подобно тому, как не всегда известен точный тип size_type элемента вектора или строки (см. раздел 3.2.2), мы обычно не знаем (да и не обязаны знать) точный тип итератора. Как и в случае с типом size_type, библиотечные типы, у которых есть итераторы, определяют типы по имени iterator и const_iterator, которые представляют фактические типы итераторов.

vector::iterator it;        // it позволяет читать и записывать

                                 // в элементы вектора vector

string::iterator it2;            // it2 позволяет читать и записывать

                                 // символы в строку

vector::const_iterator it3; // it3 позволяет читать, но не

                                 // записывать элементы

string::const_iterator it4;      // it4 позволяет читать, но не

                                 // записывать символы

Тип const_iterator ведет себя как константный указатель (см. раздел 2.4.2). Как и константный указатель, тип const_iterator позволяет читать, но не писать в элемент, на который он указывает; объект типа iterator позволяет и читать, и записывать. Если вектор или строка являются константой, можно использовать итератор только типа const_iterator. Если вектор или строка на являются константой, можно использовать итератор и типа iterator, и типа const_iterator.

Терминология. Итераторы и типы итераторов

Термин итератор (iterator) используется для трех разных сущностей. Речь могла бы идти о концепции итератора, или о типе iterator , определенном классом контейнера, или об объекте итератора.

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

Каждый класс контейнера определяет тип по имени iterator , который обеспечивает действия концептуального итератора.

Функции begin() и end()

Тип, возвращаемый функциями begin() и end(), зависит от константности объекта, для которого они были вызваны. Если объект является константой, то функции begin() и end() возвращают итератор типа const_iterator; если объект не константа, они возвращают итератор типа iterator.

vector v;

const vector cv;

auto it1 = v.begin();  // it1 имеет тип vector::iterator

auto it2 = cv.begin(); // it2 имеет тип vector::const_iterator

Зачастую это стандартное поведение желательно изменить. По причинам, рассматриваемым в разделе 6.2.3, обычно лучше использовать константный тип (такой как const_iterator), когда необходимо только читать, но не записывать в объект. Чтобы позволить специально задать тип const_iterator, новый стандарт вводит две новые функции, cbegin() и cend():

auto it3 = v.cbegin(); // it3 имеет тип vector::const_iterator

Подобно функциям-членам begin() и end(), эти функции-члены возвращают итераторы на первый и следующий после последнего элементы контейнера. Но независимо от того, является ли вектор (или строка) константой, они возвращают итератор типа const_iterator.

Объединение обращения к значению и доступа к члену

При обращении к значению итератора получается объект, на который указывает итератор. Если этот объект имеет тип класса, то может понадобиться доступ к члену полученного объекта. Например, если есть вектор строк, то может понадобиться узнать, не пуст ли некий элемент. С учетом, что it — это итератор данного вектора, можно следующим образом проверить, не пуста ли строка, на которую он указывает:

(*it).empty()

По причинам, рассматриваемым в разделе 4.1.2, круглые скобки в части (*it).empty() необходимы. Круглые скобки требуют применить оператор обращения к значению к итератору it, а к результату применить точечный оператор (см. раздел 1.5.2). Без круглых скобок точечный оператор относился бы к итератору it, а не к полученному объекту.

(*it).empty() // обращение к значению it и вызов функции-члена empty()

              // полученного объекта

*it.empty() // ошибка: попытка вызова функции-члена empty()

            //  итератора it,

            // но итератор it не имеет функции-члена empty()

Второе выражение интерпретируется как запрос на выполнение функции-члена empty() объекта it. Но it — это итератор, и он не имеет такой функции. Следовательно, второе выражение ошибочно.

Чтобы упростить такие выражения, язык предоставляет оператор стрелки (arrow operator) (оператор ->). Оператор стрелки объединяет обращение к значению и доступ к члену. Таким образом, выражение it->mem является синоним выражения (*it).mem.

Предположим, например, что имеется вектор vector по имени text, содержащий данные из текстового файла. Каждый элемент вектора — это либо предложение, либо пустая строка, представляющая конец абзаца. Если необходимо отобразить содержимое первого параграфа из вектора text, то можно было бы написать цикл, который перебирает вектор text, пока не встретится пустой элемент.

// отобразить каждую строку вектора text до первой пустой строки

for (auto it = text.cbegin();

 it != text.cend() && !it->empty(); ++it)

 cout << *it << endl;

Код начинается с инициализации итератора it указанием на первый элемент вектора text. Цикл продолжается до тех пор, пока не будут обработаны все элементы вектора text или пока не встретится пустой элемент. Пока есть элементы и текущий элемент не пуст, он отображается. Следует заметить, что, поскольку цикл только читает элементы, но не записывает их, здесь для управления итерацией используются функции cbegin() и cend().

Некоторые операции с векторами делают итераторы недопустимыми

В разделе 3.3.2 упоминался тот факт, что векторы способны расти динамически. Обращалось также внимание на то, что нельзя добавлять элементы в вектор в цикле серийного оператора for. Еще одно замечание: любая операция, такая как вызов функции push_back(), изменяет размер вектора и способна сделать недопустимыми все итераторы данного вектора. Более подробная информация по этой теме приведена в разделе 9.3.6.

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

 

3.4.2. Арифметические действия с итераторами

Инкремент итератора перемещает его на один элемент. Инкремент поддерживают итераторы всех библиотечных контейнеров. Аналогично операторы == и != можно использовать для сравнения двух допустимых итераторов (см. раздел 3.4) любых библиотечных контейнеров.

Итераторы строк и векторов поддерживают дополнительные операции, позволяющие перемещать итераторы на несколько позиций за раз. Они также поддерживают все операторы сравнения. Эти операторы зачастую называют арифметическими действиями с итераторами (iterator arithmetic). Они приведены в табл. 3.7.

Таблица 3.7. Операции с итераторами векторов и строк

Арифметические операции с итераторами

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

// вычислить итератор на элемент, ближайший к середине вектора vi

auto mid = vi.begin() + vi.size() / 2;

Если у вектора vi 20 элементов, то результатом vi.size()/2 будет 10. В данном случае переменной mid будет присвоено значение, равное vi.begin() + 10. С учетом, что нумерация индексов начинаются с 0, это тот же элемент, что и vi[10], т.е. элемент на десять позиций от начала.

Кроме сравнения двух итераторов на равенство, итераторы векторов и строк можно сравнить при помощи операторов сравнения (<, <=, >, >=). Итераторы должны быть допустимы, т.е. должны обозначать элементы (или следующую позицию за концом) того же вектора или строки. Предположим, например, что it является итератором в том же векторе, что и mid. Следующим образом можно проверить, указывает ли итератор it на элемент до или после итератора mid:

if (it < mid)

 // обработать элементы в первой половине вектора vi

Можно также вычесть два итератора, если они указывают на элементы (или следующую позицию за концом) того же вектора или строки. Результат — дистанция между итераторами. Под дистанцией подразумевается значение, на которое следует изменить один итератор, чтобы получить другой. Результат имеет целочисленный знаковый тип difference_type. Тип difference_type определен и для вектора, и для строки. Этот тип знаковый, поскольку результатом вычитания может оказаться отрицательное значение.

Использование арифметических действий с итераторами

Классическим алгоритмом, использующим арифметические действия с итераторами, является двоичный поиск (binary search). Двоичный (бинарный) поиск ищет специфическое значение в отсортированной последовательности. Алгоритм работает так: сначала исследуется элемент, ближайший к середине последовательности. Если это искомый элемент, работа закончена. В противном случае, если этот элемент меньше искомого, поиск продолжается только среди элементов после исследованного. Если средний элемент больше искомого, поиск продолжается только в первой половине. Вычисляется новый средний элемент оставшегося диапазона, и действия продолжаются, пока искомый элемент не будет найден или пока не исчерпаются элементы.

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

// текст должен быть отсортирован

// beg и end ограничивают диапазон, в котором осуществляется поиск

auto beg = text.begin(), end = text.end();

auto mid = text.begin() + (end - beg)/2; // исходная середина

// пока еще есть элементы и искомый не найден

while (mid != end && *mid != sought) {

 if (sought < *mid) // находится ли искомый элемент в первой половине?

  end = mid;        // если да, то изменить диапазон, игнорируя вторую

                    // половину

 else               // искомый элемент во второй половине

  beg = mid + 1;    // начать поиск с элемента сразу после середины

 mid = beg + (end - beg)/2; // новая середина

}

Код начинается с определения трех итераторов: beg будет первым элементом в диапазоне, end — элементом после последнего, a mid — ближайшим к середине. Инициализируем эти итераторы значениями, охватывающими весь диапазон вектора vector по имени text.

Сначала цикл проверяет, не пуст ли диапазон. Если значение итератора mid равно текущему значению итератора end, то элементы для поиска исчерпаны. В таком случае условие ложно и цикл while завершается. В противном случае итератор mid указывает на элемент, который проверяется на соответствие искомому. Если это так, то цикл завершается.

Если элементы все еще есть, код в цикле while корректирует диапазон, перемещая итератор end или beg. Если обозначенный итератором mid элемент больше, чем sought, то если искомый элемент и есть в векторе, он находится перед элементом, обозначенным итератором mid. Поэтому можно игнорировать элементы после середины, что мы и делаем, присваивая значение итератора mid итератору end. Если значение *mid меньше, чем sought, элемент должен быть в диапазоне элементов после обозначенного итератором mid. В данном случае диапазон корректируется присвоением итератору beg позиции сразу после той, на которую указывает итератор mid. Уже известно, что mid не указывает на искомый элемент, поэтому его можно исключить из диапазона.

В конце цикла while итератор mid будет равен итератору end либо будет указывать на искомый элемент. Если итератор mid равен end, то искомого элемента нет в векторе text.

Упражнения раздела 3.4.2

Упражнение 3.24. Переделайте последнее упражнение раздела 3.3.3 с использованием итераторов.

Упражнение 3.25. Перепишите программу кластеризации оценок из раздела 3.3.3 с использованием итераторов вместо индексации.

Упражнение 3.26. Почему в программе двоичного поиска использован код mid = beg + (end - beg) / 2;, а не mid = (beg + end) / 2;?

 

Массив (array) — это структура данных, подобная библиотечному типу vector (см. раздел 3.3), но с другим соотношением между производительностью и гибкостью. Как и вектор, массив является контейнером безымянных объектов одинакового типа, к которым обращаются по позиции. В отличие от вектора, массивы имеют фиксированный размер; добавлять элементы к массиву нельзя. Поскольку размеры массивов постоянны, они иногда обеспечивают лучшую производительность во время выполнения приложений. Но это преимущество приобретается за счет потери гибкости.

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

 

3.5.1. Определение и инициализация встроенных массивов

Массив является составным типом (см. раздел 2.3). Оператор объявления массива имеет форму a[d], где а — имя; d — размерность определяемого массива. Размерность задает количество элементов массива, она должна быть больше нуля. Количество элементов — это часть типа массива, поэтому она должна быть известна на момент компиляции. Следовательно, размерность должна быть константным выражением (см. раздел 2.4.4).

unsigned cnt = 42;          // неконстантное выражение

constexpr unsigned sz = 42; // константное выражение

                            // constexpr см. p. 2.4.4

int arr[10];                // массив десяти целых чисел

int *parr[sz];              // массив 42 указателей на int

string bad[cnt];            // ошибка: cnt неконстантное выражение

string strs[get_size()];    // ok, если get_size - constexpr,

                            // в противном случае - ошибка

По умолчанию элементы массива инициализируются значением по умолчанию (раздел 2.2.1).

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

При определении массива необходимо указать тип его элементов. Нельзя использовать спецификатор auto для вывода типа из списка инициализаторов. Подобно вектору, массив содержит объекты. Таким образом, невозможен массив ссылок.

Явная инициализация элементов массива

Массив допускает списочную инициализацию (см. раздел 3.3.1) элементов. В этом случае размерность можно опустить. Если размерность отсутствует, компилятор выводит ее из количества инициализаторов. Если размерность определена, количество инициализаторов не должно превышать ее.

Если размерность больше количества инициализаторов, то инициализаторы используются для первых элементов, а остальные инициализируются по умолчанию (см. раздел 3.3.1):

const unsigned sz = 3;

int ia1[sz] = {0, 1, 2};      // массив из трех целых чисел со

                              // значениями 0, 1, 2

int a2[] = {0, 1, 2};         // массив размером 3 элемента

int a3[5] = {0, 1, 2};        // эквивалент a3[] = {0, 1, 2, 0, 0}

string a4[3]Согласно другой трактовке, исключение — это объект системного или пользовательского класса, создаваемого операционной системой или кодом программы в ответ на обстоятельства, либо не допускающие дальнейшего нормального выполнения программы, либо определенные пользователем. Обработка исключений в приложении позволяет корректно выйти из затруднительной ситуации. — Примеч. ред .
= {"hi", "bye"}; // эквивалент a4[] = {"hi", "bye", ""}

int a5[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
= {0, 1, 2};        // ошибка: слишком много инициализаторов

Особенности символьных массивов

У символьных массивов есть дополнительная форма инициализации: строковым литералом (см. раздел 2.1.3). Используя эту форму инициализации, следует помнить, что строковые литералы заканчиваются нулевым символом. Этот нулевой символ копируется в массив наряду с символами литерала.

char a1[] = {'C', '+', '+'};       // списочная инициализация без

                                   // нулевого символа

char а2[] = {'C', '+', '+', '\0'}; // списочная инициализация с явным

                                   // нулевым символом

char a3[] = "С++";                 // нулевой символ добавляется

                                   // автоматически

const char a4[6] = "Daniel";       // ошибка: нет места для нулевого

                                   // символа!

Массив a1 имеет размерность 3; массивы а2 и a3 — размерности 4. Определение массива a4 ошибочно. Хотя литерал содержит только шесть явных символов, массив a4 должен иметь по крайней мере семь элементов, т.е. шесть для самого литерала и один для нулевого символа.

Не допускается ни копирование, ни присвоение

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

int a[] = {0, 1, 2}; // массив из трех целых чисел

int a2[] = a;        // ошибка: нельзя инициализировать один массив

                     // другим

а2 = a;              // ошибка: нельзя присваивать один массив другому

Некоторые компиляторы допускают присвоение массивов при применении расширения компилятора (compiler extension). Как правило, использования нестандартных средств следует избегать, поскольку они не будут работать на других компиляторах.

Понятие сложных объявлений массива

Как и векторы, массивы способны содержать объекты большинства типов. Например, может быть массив указателей. Поскольку массив — это объект, можно определять и указатели, и ссылки на массивы. Определение массива, содержащего указатели, довольно просто, определение указателя или ссылки на массив немного сложней.

int *ptrs[10];            // ptrs массив десяти указателей на int

int &refs[10] = /* ? */;  // ошибка: массив ссылок невозможен

int (*Parray)[10] = &arr; // Parray указывает на массив из десяти int

int (&arrRef)[10] = arr;  // arrRef ссылается на массив из десяти ints

Обычно модификаторы типа читают справа налево. Читаем определение ptrs справа налево (см. раздел 2.3.3): определить массив размером 10 по имени ptrs для хранения указателей на тип int.

Определение Parray также стоит читать справа налево. Поскольку размерность массива следует за объявляемым именем, объявление массива может быть легче читать изнутри наружу, а не справа налево. Так намного проще понять тип Parray. Объявление начинается с круглых скобок вокруг части *Parray, означающей, что Parray — указатель. Глядя направо, можно заметить, что указатель Parray указывает на массив размером 10. Глядя влево, можно заметить, что элементами этого массива являются целые числа. Таким образом, Parray — это указатель на массив из десяти целых чисел. Точно так же часть (&arrRef) означает, что arrRef — это ссылка, а типом, на который она ссылается, является массив размером 10, хранящий элементы типа int.

Конечно, нет никаких ограничений на количество применяемых модификаторов типа.

int *(&arry)[10]=ptrs; // arry - ссылка на массив из десяти указателей

Читая это объявление изнутри наружу, можно заметить, что arry — это ссылка. Глядя направо, можно заметить, что объект, на который ссылается arry, является массивом размером 10. Глядя влево, можно заметить, что типом элемента является указатель на тип int. Таким образом, arry — это ссылка на массив десяти указателей.

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

Упражнения раздела 3.5.1

Упражнение 3.27. Предположим, что функция txt_size() на получает никаких аргументов и возвращают значение типа int. Объясните, какие из следующих определений недопустимы и почему?

unsigned buf_size = 1024;

(a) int ia[buf_size];   (b) int ia[4 * 7 - 14];

(c) int ia[txt_size()]; (d) char st[11] = "fundamental";

Упражнение 3.28. Какие значения содержатся в следующих массивах?

string sa[10];

int ia[10];

int main() {

 string sa2[10];

 int ia2[10];

}

Упражнение 3.29. Перечислите некоторые из недостатков использования массива вместо вектора.

 

3.5.2. Доступ к элементам массива

Подобно библиотечным типам vector и string, для доступа к элементам массива можно использовать серийный оператор for или оператор индексирования ([]) (subscript). Как обычно, индексы начинаются с 0. Для массива из десяти элементов используются индексы от 0 до 9, а не от 1 до 10.

При использовании переменной для индексирования массива ее обычно определяют как имеющую тип size_t. Тип size_t — это машинозависимый беззнаковый тип, гарантированно достаточно большой для содержания размера любого объекта в памяти. Тип size_t определен в заголовке cstddef, который является версией С++ заголовка stddef.h библиотеки С.

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

// подсчет количества оценок в кластере по десять: 0--9,

// 10--19, ... 90--99, 100

unsigned scores[11] = {}; // 11 ячеек, все со значением 0

unsigned grade;

while (cin >> grade) {

 if (grade <= 100)

  ++scores[grade/10]; // приращение счетчика текущего кластера

}

Единственное очевидное различие между этой программой и приведенной в разделе 3.3.3 в объявлении массива scores. В данной программе это массив из 11 элементов типа unsigned. Не столь очевидно то различие, что оператор индексирования в данной программе тот, который определен как часть языка. Этот оператор применяется с операндами типа массива. Оператор индексирования, используемый в программе в разделе 3.3.3, был определен библиотечным шаблоном vector и применялся к операндам типа vector.

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

for (auto i : scores) // для каждого счетчика в scores

 cout << i << " ";    // отобразить его значение

cout << endl;

Поскольку размерность является частью типа каждого массива, системе известно количество элементов в массиве scores. Используя средства серийного оператора for, перебором можно управлять и не самостоятельно.

Проверка значений индекса

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

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

Упражнения раздела 3.5.2

Упражнение 3.30. Выявите ошибки индексации в следующем коде

constexpr size_t array size = 10;

int ia[array_size];

for (size_t ix = 1; ix <= array size; ++ix)

 ia[ix] = ix;

Упражнение 3.31. Напишите программу, где определен массив из десяти целых чисел, каждому элементу которого присвоено значение, соответствующее его позиции в массиве.

Упражнение 3.32. Скопируйте массив, определенный в предыдущем упражнении, в другой массив. Перезапишите эту программу так, чтобы использовались векторы.

Упражнение 3.33. Что будет, если не инициализировать массив scores в программе оценок из данного раздела?

 

3.5.3. Указатели и массивы

Указатели и массивы в языке С++ тесно связаны. В частности, как будет продемонстрировано вскоре, при использовании массивов компилятор обычно преобразует их в указатель.

Обычно указатель на объект получают при помощи оператора обращения к адресу (см. раздел 2.3.2). По правде говоря, оператор обращения к адресу может быть применен к любому объекту, а элементы в массиве — объекты. При индексировании массива результатом является объект в этой области массива. Подобно любым другим объектам, указатель на элемент массива можно получить из адреса этого элемента:

string nums[] = {"one", "two", "three"}; // массив строк

string *p = &nums[0]; // p указывает на первый элемент массива nums

Однако у массивов есть одна особенность — места их использования компилятор автоматически заменяет указателем на первый элемент.

string *p2 = nums; // эквивалент p2 = &nums[0]

В большинстве выражений, где используется объект типа массива, в действительности используется указатель на первый элемент в этом массиве.

Существует множество свидетельств того факта, что операции с массивами зачастую являются операциями с указателями. Одно из них — при использовании массива как инициализатора переменной, определенной с использованием спецификатора auto (см. раздел 2.5.2), выводится тип указателя, а не массива.

int ia[] = {0,1,2,3,4,5,6,7,8,9}; // ia - массив из десяти целых чисел

auto ia2(ia); // ia2 - это int*, указывающий на первый элемент в ia

ia2 = 42;     // ошибка: ia2 - указатель, нельзя присвоить указателю

              // значение типа int

Хотя ia является массивом из десяти целых чисел, при его использовании в качестве инициализатора компилятор рассматривает это как следующий код:

auto ia2(&ia[0]); // теперь ясно, что ia2 имеет тип int*

Следует заметить, что это преобразование не происходит, если используется спецификатор decltype (см. раздел 2.5.3). Выражение decltype(ia) возвращает массив из десяти целых чисел:

// ia3 - массив из десяти целых чисел

decltype(ia) ia3 = {0,1,2,3,4,5,6,7,8,9};

ia3 = p;    // ошибка: невозможно присвоить int* массиву

ia3[4]Здесь и везде в оригинале именно adapt o r, а не adapt e r. — Примеч. ред .
= i; // ok: присвоить значение i элементу в массиве ia3

Указатели — это итераторы

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

int arr[] = {0,1,2,3,4,5,6,7,8,9};

int *p = arr; // p указывает на первый элемент в arr

++p;          // p указывает на arr[1]На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .

Подобно тому, как итераторы можно использовать для перебора элементов вектора, указатели можно использовать для перебора элементов массива. Конечно, для этого нужно получить указатели на первый элемент и элемент, следующий после последнего. Как упоминалось только что, указатель на первый элемент можно получить при помощи самого массива или при обращении к адресу первого элемента. Получить указатель на следующий элемент после последнего можно при помощи другого специального свойства массива. Последний элемент массива arr находится в позиции 9, а адрес несуществующего элемента массива, следующего после него, можно получить так:

int *е = &arr[10]; // указатель на элемент после

                   //  последнего в массиве arr

Единственное, что можно сделать с этим элементом, так это получить его адрес, чтобы инициализировать указатель е. Как и итератор на элемент после конца (см. раздел 3.4.1), указатель на элемент после конца не указывает ни на какой элемент. Поэтому нельзя ни обратиться к его значению, ни прирастить.

Используя эти указатели, можно написать цикл, выводящий элементы массива arr.

for (int *b = arr; b != e; ++b)

 cout << *b << endl; // вывод элементов arr

Библиотечные функции begin() и end()

Указатель на элемент после конца можно вычислить, но этот подход подвержен ошибкам. Чтобы облегчить и обезопасить использование указателей, новая библиотека предоставляет две функции: begin() и end(). Эти функции действуют подобно одноименным функциям-членам контейнеров (см. раздел 3.4.1). Однако массивы — не классы, и данные функции не могут быть функциями-членами. Поэтому для работы они получают массив в качестве аргумента.

int ia[] = {0,1,2,3,4,5,6,7,8,9}; // ia - массив из десяти целых чисел

int *beg = begin(ia); // указатель на первый элемент массива ia

int *last = end(ia);  // указатель на следующий элемент ia за последним

Функция begin() возвращает указатель на первый, а функция end() на следующий после последнего элемент данного массива. Эти функции определены в заголовке iterator.

Используя функции begin() и end(), довольно просто написать цикл обработки элементов массива. Предположим, например, что массив arr содержит значения типа int. Первое отрицательное значение в массиве arr можно найти следующим образом:

// pbeg указывает на первый, a pend на следующий после последнего

// элемент массива arr

int *pbeg = begin(arr), *pend = end(arr);

// найти первый отрицательный элемент, остановиться, если просмотрены

// все элементы

while (pbeg != pend && *pbeg >= 0)

 ++pbeg;

Код начинается с определения двух указателей типа int по имени pbeg и pend. Указатель pbeg устанавливается на первый элемент массива arr, a pend — на следующий элемент после последнего. Условие цикла while использует указатель pend, чтобы узнать, безопасно ли обращаться к значению указателя pbeg. Если указатель pbeg действительно указывает на элемент, выполняется проверка результата обращения к его значению на наличие отрицательного значения. Если это так, то условие ложно и цикл завершается. В противном случае указатель переводится на следующий элемент.

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

Арифметические действия с указателями

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

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

constexpr size_t sz = 5;

int arr[sz] = {1,2,3,4,5};

int *ip = arr;     // эквивалент int *ip = &arr[0]

int *ip2 = ip + 4; // ip2 указывает на arr[4]Здесь и везде в оригинале именно adapt o r, а не adapt e r. — Примеч. ред .
, последний элемент в arr

Результатом добавления 4 к указателю ip будет указатель на элемент, расположенный в массиве на четыре позиции далее от того, на который в настоящее время указывает ip.

Результатом добавления целочисленного значения к указателю должен быть указатель на элемент (или следующую позицию после конца) в том же массиве:

// ok: arr преобразуется в указатель на его первый элемент;

// p указывает на позицию после конца arr

int *p = arr + sz;  // использовать осмотрительно - не обращаться

                    // к значению!

int *p2 = arr + 10; // ошибка: arr имеет только 5 элементов;

                    // значение p2 неопределенно

При сложении arr и sz компилятор преобразует arr в указатель на первый элемент массива arr. При добавлении sz к этому указателю получается указатель на позицию sz (т.е. на позицию 5) этого массива. Таким образом, он указывает на следующую позицию после конца массива arr. Вычисление указателя на более чем одну позицию после последнего элемента является ошибкой, хотя компилятор таких ошибок не обнаруживает.

Подобно итераторам, вычитание двух указателей дает дистанцию между ними. Указатели должны указывать на элементы в том же массиве:

auto n = end(arr) - begin(arr); // n - 5, количество элементов

                                // массива arr

Результат вычитания двух указателей имеет библиотечный тип ptrdiff_t. Как и тип size_t, тип ptrdiff_t является машинозависимым типом, определенным в заголовке cstddef. Поскольку вычитание способно возвратить отрицательное значение, тип ptrdiff_t — знаковый целочисленный.

Для сравнения указателей на элементы (или позицию за концом) массива можно использовать операторы сравнения. Например, элементы массива arr можно перебрать следующим образом:

int *b = arr, *е = arr + sz;

while (b < e) {

 // используется *b

 ++b;

}

Нельзя использовать операторы сравнения для указателей на два несвязанных объекта.

int i = 0, sz = 42;

int *p = &i, *е = &sz;

// неопределенно: p и е не связаны; сравнение бессмысленно!

while (p < е)

Хотя на настоящий момент смысл может быть и неясен, но следует заметить, что арифметические действия с указателями допустимы также для нулевых указателей (см. раздел 2.3.2) и для указателей на объекты, не являющиеся массивом. В последнем случае указатели должны указывать на тот же объект или следующий после него. Если p — нулевой указатель, то к нему можно добавить (или вычесть) целочисленное константное выражение (см. раздел 2.4.4) со значением 0. Можно также вычесть два нулевых указателя из друг друга, и результатом будет 0.

Взаимодействие обращения к значению с арифметическими действиями с указателями

Результатом добавления целочисленного значения к указателю является указатель. Если полученный указатель указывает на элемент, то к его значению можно обратиться:

int ia[] = {0,2,4,6,8}; // массив из 5 элементов типа int

int last = *(ia + 4);   // ok: инициализирует last значением

                        //  ia[4]Здесь и везде в оригинале именно adapt o r, а не adapt e r. — Примеч. ред .
, т.е. 8

Выражение *(ia + 4) вычисляет адрес четвертого элемента после ia и обращается к значению полученного указателя. Это выражение эквивалентно выражению ia[4]Здесь и везде в оригинале именно adapt o r, а не adapt e r. — Примеч. ред .
.

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

last = *ia + 4; // ok: last = 4, эквивалент ia[0] + 4

Этот код обращается к значению ia и добавляет 4 к полученному значению. Причины подобного поведения рассматриваются в разделе 4.1.2.

#magnify.png Индексирование и указатели

Как уже упоминалось, в большинстве мест, где используется имя массива, в действительности используется указатель на первый элемент этого массива. Одним из мест, где компилятор осуществляет это преобразование, является индексирование массива.

int ia[] = {0,2,4,6,8}; // массив из 5 элементов типа int

Рассмотрим выражение ia[0], использующее имя массива. При индексировании массива в действительности индексируется указатель на элемент в этом массиве.

int i = ia[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
; // ia преобразуется в указатель на первый элемент ia

               // ia[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
выбирает элемент, на который указывает (ia + 2)

int *p = ia;   // p указывает на первый элемент в массиве ia

i = *(p + 2);  // эквивалент i = ia[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .

Оператор индексирования можно использовать для любого указателя, пока он указывает на элемент (или позицию после конца) в массиве.

int *p = &ia[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
; // p указывает на элемент с индексом 2

int j = p[1]На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .
На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .
;    // p[1]На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .
На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .
- эквивалент *(p + 1),

                 // p[1]На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .
тот же элемент, что и ia[3]Согласно другой трактовке, исключение — это объект системного или пользовательского класса, создаваемого операционной системой или кодом программы в ответ на обстоятельства, либо не допускающие дальнейшего нормального выполнения программы, либо определенные пользователем. Обработка исключений в приложении позволяет корректно выйти из затруднительной ситуации. — Примеч. ред .

int k = p[-2];   // p[-2] тот же элемент, что и ia[0]

Последний пример указывает на важное отличие между массивами и такими библиотечными типами, как vector и string, у которых есть операторы индексирования. Библиотечные типы требуют, чтобы используемый индекс был беззнаковым значением. Встроенный оператор индексирования этого не требует. Индекс, используемый со встроенным оператором индексирования, может быть отрицательным значением. Конечно, полученный адрес должен указывать на элемент (или позицию после конца) массива, на который указывает первоначальный указатель.

В отличие от индексов для векторов и строк, индекс встроенного массива не является беззнаковым.

Упражнения раздела 3.5.3

Упражнение 3.34. С учетом, что указатели p1 и p2 указывают на элементы в том же массиве, что делает следующий код? Какие значения p1 или p2 делают этот код недопустимым?

p1 += p2 - p1;

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

Упражнение 3.36. Напишите программу, сравнивающую два массива на равенство. Напишите подобную программу для сравнения двух векторов.

 

3.5.4. Символьные строки в стиле С

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

Символьный строковый литерал — это экземпляр более общей конструкции, которую язык С++ унаследовал от языка С: символьной строки в стиле С (C-style character string). Строка в стиле С не является типом данных, скорее это соглашение о представлении и использовании символьных строк. Следующие этому соглашению строки хранятся в символьных массивах и являются строкой с завершающим нулевым символом (null-terminated string). Под завершающим нулевым символом подразумевается, что последний видимый символ в строке сопровождается нулевым символом ('\0'). Для манипулирования этими строками обычно используются указатели.

Строковые функции библиотеки С

Стандартная библиотека языка С предоставляет набор функций, перечисленных в табл. 3.8, для работы со строками в стиле С. Эти функции определены в заголовке cstring, являющемся версией С++ заголовка языка С string.h.

Функции из табл. 3.8 не проверяют свои строковые параметры

Указатель (указатели), передаваемый этим функциям, должен указывать на массив (массивы) с нулевым символом в конце.

char ca[] = {'C', '+', '+'}; // без нулевого символа в конце

cout << strlen(ca) << endl;  // катастрофа: ca не завершается нулевым

                             // символом

В данном случае ca — это массив элементов типа char, но он не завершается нулевым символом. Результат непредсказуем. Вероятней всего, функция strlen() продолжит просматривать память уже за пределами массива ca, пока не встретит нулевой символ.

Таблица 3.8. Функции для символьных строк в стиле С

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

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

string s1 = "A string example";

string s2 = "A different string";

if (s1 < s2) // ложно: s2 меньше s1

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

const char ca1[] = "A string example";

const char ca2[] = "A different string";

if (ca1 < ca2) // непредсказуемо: сравниваются два адреса

Помните, что при использовании массива в действительности используются указатели на их первый элемент (см. раздел 3.5.3). Следовательно, это условие фактически сравнивает два значения const char*. Эти указатели содержат адреса разных объектов, поэтому результат такого сравнения непредсказуем.

Чтобы сравнить строки, а не значения указателей, можем использовать функцию strcmp(). Она возвращает значение 0, если строки равны, положительное или отрицательное значение, в зависимости от того, больше ли первая строка второй или меньше.

if (strcmp(ca1, ca2) < 0) // то же, что и сравнение строк s1 < s2

За размер строки отвечает вызывающая сторона

Конкатенация и копирование строк в стиле С также весьма отличается от таких же операций с библиотечным типом string. Например, если необходима конкатенация строк s1 и s2, определенных выше, то это можно сделать так:

// инициализировать largeStr результатом конкатенации строки s1,

// пробела и строки s2

string largeStr = s1 + " " + s2;

Подобное с двумя массивами, ca1 и ca2, было бы ошибкой. Выражение ca1 + ca2 попытается сложить два указателя, что некорректно и бессмысленно.

Вместо этого можно использовать функции strcat() и strcpy(). Но чтобы использовать эти функции, им необходимо передать массив для хранения результирующей строки. Передаваемый массив должен быть достаточно большим, чтобы содержать созданную строку, включая нулевой символ в конце. Хотя представленный здесь код следует традиционной схеме, потенциально он может стать причиной серьезной ошибки.

// катастрофа, если размер largeStr вычислен ошибочно

strcpy(largeStr, ca1); // копирует ca1 в largeStr

strcat(largeStr, " "); // добавляет пробел в конец largeStr

strcat(largeStr, ca2); // конкатенирует ca2 с largeStr

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

Для большинства приложений не только безопасней, но и эффективней использовать библиотечный тип string, а не строки в стиле С.

Упражнения раздела 3.5.4

Упражнение 3.37. Что делает следующая программа?

const char ca[] = {'h', 'e', 'l', 'l', 'o'};

const char *cp = ca;

while (*cp) {

 cout << *cp << endl;

 ++cp;

}

Упражнение 3.38. В этом разделе упоминалось, что не только некорректно, но и бессмысленно пытаться сложить два указателя. Почему сложение двух указателей бессмысленно?

Упражнение 3.39. Напишите программу, сравнивающую две строки. Затем напишите программу, сравнивающую значения двух символьных строк в стиле С.

Упражнение 3.40. Напишите программу, определяющую два символьных массива, инициализированных строковыми литералами. Теперь определите третий символьный массив для содержания результата конкатенации этих двух массивов. Используйте функции strcpy() и strcat() для копирования этих двух массивов в третий.

 

3.5.5. Взаимодействие с устаревшим кодом

Множество программ С++ было написано до появления стандартной библиотеки, поэтому они не используют библиотечные типы string и vector. Кроме того, многие программы С++ взаимодействуют с программами, написанными на языке С или других языках, которые не могут использовать библиотеку С++. Следовательно, программам, написанным на современном языке С++, вероятно, придется взаимодействовать с кодом, который использует символьные строки в стиле С и/или массивы. Библиотека С++ предоставляет средства, облегчающие такое взаимодействие.

#reader.png Совместное использование библиотечных строки строк в стиле С

В разделе 3.2.1 была продемонстрирована возможность инициализации строки класса string строковым литералом:

string s("Hello World"); // s содержит Hello World

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

• Символьный массив с нулевым символом в конце можно использовать для инициализации строки класса string или присвоения ей.

• Символьный массив с нулевым символом в конце можно использовать как один из операндов (но не оба) в операторе суммы класса string или как правый операнд в составном операторе присвоения (+=) класса string.

Однако нет никакого простого способа использовать библиотечную строку там, где требуется строка в стиле С. Например, невозможно инициализировать символьный указатель объектом класса string. Тем не менее класс string обладает функцией-членом c_str(), зачастую позволяющей выполнить желаемое.

char *str = s; // ошибка: нельзя инициализировать char* из string

const char *str = s.c_str(); // ok

Имя функции c_str() означает, что она возвращает символьную строку в стиле С. Таким образом, она возвращает указатель на начало символьного массива с нулевым символом в конце, содержащим те же символы, что и строка. Тип указателя const char* не позволяет изменять содержимое массива.

Допустимость массива, возвращенного функцией c_str(), не гарантируется. Любое последующее использование указателя s, способное изменить его значение, может сделать этот массив недопустимым.

Если программа нуждается в продолжительном доступе к содержимому массива, возвращенного функцией c_str(), то следует создать его копию.

Использование массива для инициализации вектора

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

int int_arr[] = {0, 1, 2, 3, 4, 5};

// вектор ivec содержит 6 элементов, каждый из которых является

// копией соответствующего элемента массива int_arr

vector ivec(begin(int_arr), end(int_arr));

Два указателя, используемые при создании вектора ivec, отмечают диапазон значений, используемых для инициализации его элементов. Второй указатель указывает на следующий элемент после последнего копируемого. В данном случае для передачи указателей на первый и следующий после последнего элементы массива int_arr использовались библиотечные функции begin() и end() (см. раздел 3.5.3). В результате вектор ivec содержит шесть элементов, значения которых совпадают со значениями соответствующих элементов массива int_arr.

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

// скопировать 3 элемента: int_arr[1]На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .
, int_arr[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
, int_arr[3]Согласно другой трактовке, исключение — это объект системного или пользовательского класса, создаваемого операционной системой или кодом программы в ответ на обстоятельства, либо не допускающие дальнейшего нормального выполнения программы, либо определенные пользователем. Обработка исключений в приложении позволяет корректно выйти из затруднительной ситуации. — Примеч. ред .

vector subVec(int_arr + 1, int_arr + 4);

Этот код создает вектор subVec с тремя элементами, значения которых являются копиями значений элементов от intarr[1]На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .
до intarr[3]Согласно другой трактовке, исключение — это объект системного или пользовательского класса, создаваемого операционной системой или кодом программы в ответ на обстоятельства, либо не допускающие дальнейшего нормального выполнения программы, либо определенные пользователем. Обработка исключений в приложении позволяет корректно выйти из затруднительной ситуации. — Примеч. ред .
.

Совет. Используйте вместо массивов библиотечные типы

Указатели и массивы на удивление сильно подвержены ошибкам. Частично проблема в концепции: указатели используются для низкоуровневых манипуляций, в них очень просто сделать тривиальные ошибки. Другие проблемы возникают из-за используемого синтаксиса, особенно синтаксиса объявлений.

Упражнения раздела 3.5.5

Упражнение 3.41. Напишите программу, инициализирующую вектор значениями из массива целых чисел.

Упражнение 3.42. Напишите программу, копирующую вектор целых чисел в массив целых чисел.

 

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

 

4.1.1. Фундаментальные концепции

Существуют унарные операторы (unary operator) и парные операторы (binary operator). Унарные операторы, такие как обращение к адресу (&) и обращение к значению (*), воздействуют на один операнд. Парные операторы, такие как равенство (==) и умножение (*), воздействуют на два операнда. Существует также (всего один) тройственный оператор (ternary operator), который использует три операнда, а также оператор вызова функции (function call), который получает неограниченное количество операндов.

Некоторые символы (symbol), например *, используются для обозначения как унарных (обращение к значению), так и парных (умножение) операторов. Представляет ли символ унарный оператор или парный, определяет контекст, в котором он используется. В использовании таких символов нет никакой взаимосвязи, поэтому их можно считать двумя разными символами.

Группировка операторов и операндов

Чтобы лучше понять порядок выполнения выражений с несколькими операторами, следует рассмотреть концепцию приоритета (precedence), порядка (associativity) и порядка вычисления (order of evaluation) операторов. Например, в следующем выражении используются сложение, умножение и деление:

5 + 10 * 20/2;

Операндами оператора * могли бы быть числа 10 и 20, либо 10 и 20/2, либо 15 и 20, либо 15 и 20/2. Понимание таких выражений и является темой следующего раздела.

Преобразование операндов

В ходе вычисления выражения операнды нередко преобразуются из одного типа в другой. Например, парные операторы обычно ожидают операндов одинакового типа. Но операторы применимы и к операндам с разными типами, если они допускают преобразование (см. раздел 2.1.2) в общий тип.

Хотя правила преобразования довольно сложны, по большей части они очевидны. Например, целое число можно преобразовать в число с плавающей запятой, и наоборот, но преобразовать тип указателя в число с плавающей точкой нельзя. Немного неочевидным может быть то, что операнды меньших целочисленных типов (например, bool, char, short и т.д.) обычно преобразуются (promotion) в больший целочисленный тип, как правило int. Более подробная информация о преобразованиях приведена в разделе 4.11.

Перегруженные операторы

Значение операторов для встроенных и составных типов определяет сам язык. Значение большинства операторов типов классов мы можем определить самостоятельно. Поскольку такие определения придают альтернативное значение существующему символу оператора, они называются перегруженными операторами (overloaded operator). Операторы >> и << библиотеки ввода и вывода, а также операторы, использовавшиеся с объектами строк, векторов и итераторов, являются перегруженными операторами.

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

#magnify.png L- и r-значения

Каждое выражение в языке С++ является либо r-значением (r-value), либо l-значением (l-value). Эти названия унаследованы от языка С и первоначально имели простую мнемоническую цель: l-значения могли стоять слева от оператора присвоения, а r-значения не могли.

В языке С++ различие не так просто. В языке С++ выражение l-значения возвращает объект или функцию. Однако некоторые l-значения, такие как константные объекты, не могут быть левым операндом присвоения. Кроме того, некоторые выражения возвращают объекты, но возвращают их как r-, а не l-значения. Короче говоря, при применении объекта в качестве r-значения используется его значение (т.е. его содержимое). При применении объекта в качестве l-значения используется его идентификатор (т.е. его область в памяти).

Операторы различаются по тому, требуют ли они операндов l- или r-значения, а также по тому, возвращают ли они l- или r-значения. Важный момент здесь в том, что (за одним исключением, рассматриваемым в разделе 13.6) l-значение можно использовать там, где требуется r-значение, однако нельзя использовать r-значение там, где требуется l-значение (т.е. область). Когда l-значение применяется вместо r-значения, используется содержимое объекта (его значение). Мы уже использовали несколько операторов, которые задействовали l-значения.

• В качестве своего левого операнда оператор присвоения требует (неконстантного) l-значения и возвращает свой левый операнд как l-значение.

• Оператор обращения к адресу (см. раздел 2.3.2) требует в качестве операнда l-значение и возвращает указатель на свой операнд как r-значение.

• Встроенные операторы обращения к значению и индексирования (см. раздел 2.3.2 и раздел 3.5.2), а также обращение к значению итератора и операторы индексирования строк и векторов (см. раздел 3.4.1, раздел 3.2.3 и раздел 3.3.3) возвращают l-значения.

• Операторы инкремента и декремента, как встроенные, так и итератора (см. раздел 1.4.1 и раздел 3.4.1), требуют l-значения в качестве операндов. Их префиксные версии (которые использовались до сих пор) также возвращают l-значения.

Рассматривая операторы, следует обратить внимание на то, должен ли операнд быть l-значением и возвращает ли он l-значение.

L- и r-значения также различаются при использовании спецификатора decltype (см. раздел 2.5.3). При применении спецификатора decltype к выражению (отличному от переменной) результатом будет ссылочный тип, если выражение возвращает l-значение. Предположим, например, что указатель p имеет тип int*. Поскольку обращение к значению возвращает l-значение, выражение decltype(*p) имеет тип int&. С другой стороны, поскольку оператор обращения к адресу возвращает r-значение, выражение decltype(&p) имеет тип int**, т.е. указатель на указатель на тип int.

 

4.1.2. Приоритет и порядок

Выражения с двумя или несколькими операторами называются составными (compound expression). Результат составного выражения определяет способ группировки операндов в отдельных операторах. Группировку операндов определяют приоритет и порядок. Таким образом, они определяют, какие части выражения будут операндами для каждого из операторов в выражении. При помощи скобок программисты могут изменять эти правила, обеспечивая необходимую группировку.

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

• Благодаря приоритету результатом выражения 3 + 4*5 будет 23, а не 35.

• Благодаря порядку результатом выражения 20-15-3 будет 2, а не 8.

В более сложном примере при вычислении слева направо следующего выражения получается 20:

6 + 3 * 4 / 2 + 2

Вполне возможны и другие результаты: 9, 14 и 36. В языке С++ результат составит 14, поскольку это выражение эквивалентно следующему:

// здесь круглые скобки соответствуют стандартному приоритету и порядку

((6 + ((3 * 4) / 2)) + 2)

Круглые скобки переопределяют приоритет и порядок

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

// круглые скобки обеспечивают альтернативные группировки

cout << (6 + 3) * (4 / 2 + 2) << endl; // выводит 36

cout << ((6 + 3) * 4) / 2 + 2 << endl; // выводит 20

cout << 6 + 3 * 4 / (2 + 2) << endl;   // выводит 9

#reader.png Когда важны приоритет и порядок

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

int ia[] = {0,2,4,6,8}; // массив из 5 элементов типа int

int last = *(ia + 4);   // ok: инициализирует last значением

                        //  ia[4]Здесь и везде в оригинале именно adapt o r, а не adapt e r. — Примеч. ред .
, т.е. 8

last = *ia + 4;         // last = 4, эквивалент ia[0] + 4

Если необходим доступ к элементу в области ia+4, то круглые скобки вокруг сложения необходимы. Без круглых скобок сначала группируется часть *ia, а к полученному значению добавляется 4.

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

cin >> v1 >> v2; // читать в v1, а затем в v2

В таблице раздела 4.12 перечислены все операторы, организованные по сегментам. У операторов в каждом сегменте одинаковый приоритет, причем сегменты с более высоким приоритетом расположены выше. Например, префиксный оператор инкремента и оператор обращения к значению имеют одинаковый приоритет, который выше, чем таковой у арифметических операторов. Таблица содержит ссылки на разделы, где описан каждый из операторов. Многие из этих операторов уже применялось, а большинство из остальных рассматривается в данной главе. Подробней некоторые из операторов рассматриваются позже.

Упражнения раздела 4.1.2

Упражнение 4.1. Какое значение возвратит выражение 5 + 10 * 20/2?

Упражнение 4.2. Используя таблицу раздела 4.12, расставьте скобки в следующих выражениях, чтобы обозначить порядок группировки операндов:

(а) * vec.begin() (b) * vec.begin() + 1

 

4.1.3. Порядок вычисления

Приоритет определяет группировку операндов. Но он ничего не говорит о порядке, в котором обрабатываются операнды. В большинстве случаев порядок не определен. В следующем выражении известно, что функции f1() и f2() будут вызваны перед умножением:

int i = f1() * f2();

В конце концов, умножаются именно их результаты. Тем не менее нет никакого способа узнать, будет ли функция f1() вызвана до функции f2(), или наоборот.

Для операторов, которые не определяют порядок вычисления, выражение, пытающееся обратиться к тому же объекту и изменить его, было бы ошибочным. Выражения, которые действительно так поступают, имеют непредсказуемое поведение (см. раздел 2.1.2). Вот простой пример: оператор << не дает никаких гарантий в том, как и когда обрабатываются его операнды. В результате следующее выражение вывода непредсказуемо:

int i = 0;

cout << i << " " << ++i << endl; // непредсказуемо

Непредсказуемость этой программы в том, что нет никакой возможности сделать выводы о ее поведении. Компилятор мог бы сначала обработать часть ++i, а затем часть i, тогда вывод будет 1 1. Но компилятор мог бы сначала обработать часть i, тогда вывод будет 0 1. Либо компилятор мог бы сделать что-то совсем другое. Поскольку у этого выражения неопределенное поведение, программа ошибочна, независимо от того, какой код создает компилятор.

Четыре оператора действительно гарантируют порядок обработки операндов. В разделе 3.2.3 упоминалось о том, что оператор логического AND (&&) гарантирует выполнение сначала левого операнда. Кроме того, он гарантирует, что правый операнд обрабатывается только при истинности левого операнда. Другими операторами, гарантирующими порядок обработки операндов, являются оператор логического OR (||) (раздел 4.3), условный оператор (? :) (раздел 4.7) и оператор запятая (,) (раздел 4.10).

#magnify.png Порядок вычисления, приоритет и порядок операторов

Порядок вычисления операндов не зависит от приоритета и порядка операторов. Рассмотрим следующее выражение:

f() + g() * h() + j()

• Приоритет гарантирует умножение результатов вызова функций g() и h().

• Порядок гарантирует добавление результата вызова функции f() к произведению g() и h(), а также добавление результата сложения к результату вызова функции j().

• Однако нет никаких гарантий относительно порядка вызова этих функций.

Если функции f(), g(), h() и j() являются независимыми и не влияют на состояние тех же объектов или выполняют ввод и вывод, то порядок их вызова несуществен. Но если любые из этих функций действительно воздействуют на тот же объект, то выражение ошибочно, а его поведение непредсказуемо.

Упражнения раздела 4.1.3

Упражнение 4.3. Порядок вычисления большинства парных операторов оставляется неопределенным, чтобы предоставить компилятору возможность для оптимизации. Эта стратегия является компромиссом между созданием эффективного кода и потенциальными проблемами в использовании языка программистом. Полагаете этот компромисс приемлемым? Кто-то да, кто- то нет.

Совет. Манипулирование составными выражениями

При написании составных выражений могут пригодиться два эмпирических правила.

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

2. При изменении значения операнда не используйте этот операнд в другом месте того же оператора.

Важнейшим исключением из второго правила является случай, когда часть выражения, изменяющая операнд, сама является операндом другой части выражения. Например, в выражении *++iter инкремент изменяет значение итератора iter , а измененное значение используется как операнд оператора * . В этом и подобных выражениях порядок обработки операндов не является проблемным. Но в больших выражениях те части, которые изменяют операнд, должны обрабатываться в первую очередь. Такой подход не создает никаких проблем и применяется достаточно часто.

 

В языке С++ некоторые типы взаимосвязаны. Когда два типа взаимосвязаны, объект или значение одного типа можно использовать там, где ожидается операнд связанного типа. Два типа считаются связанными, если между ними возможно преобразование (conversion).

Для примера рассмотрим следующее выражение, инициализирующее переменную ival значением 6:

int ival = 3.541 + 3; // компилятор может предупредить о потере точности

Операндами сложения являются значения двух разных типов: 3.541 имеет тип double а 3 — int. Вместо попытки суммирования двух значений разных типов язык С++ определяет набор преобразований, позволяющих преобразовать операнды в общий тип. Эти преобразования выполняются автоматически без вмешательства программиста, а иногда и без его ведома. Поэтому они и называются неявным преобразованием (implicit conversion).

Неявные преобразования между арифметическими типами определены так, чтобы по возможности сохранять точность. Как правило, если у выражения есть и целочисленное значение, и значение с плавающей запятой, целое число преобразуется в число с плавающей точкой. В данном случае значение 3 преобразуется в тип double, осуществляется сложение чисел с плавающей запятой, и возвращается результат типа double.

Затем происходит инициализация. При инициализации доминирует тип инициализируемого объекта. Поэтому инициализатор преобразуется в его тип. В данном случае результат сложения типа double преобразуется в тип int и используется для инициализации переменной ival. Преобразование типа double в тип int усекает значение типа double, отбрасывая десятичную часть. В данном случае выражение присваивает переменной ival значение 6.

Когда происходят неявные преобразования

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

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

• В условиях нелогические выражения преобразуются в тип bool.

• При инициализации инициализатор преобразуется в тип переменной; при присвоении правый операнд преобразуется в тип левого.

• В арифметических выражениях и выражениях отношения с операндами смешанных типов происходит преобразование в общий тип.

• Преобразования происходят также при вызове функций, как будет продемонстрировано в главе 6.

 

4.11.1. Арифметические преобразования

Арифметические преобразования (arithmetic conversion), впервые представленные в разделе 2.1.2, преобразуют один арифметический тип в другой. Иерархию преобразований типов определяют правила, согласно которым операнды операторов преобразуются в самый большой общий тип. Например, если один операнд имеет тип long double, то второй операнд преобразуется тоже в тип long double независимо от своего типа. Короче говоря, в выражениях, где используются целочисленные значения и значения с плавающей точкой, целочисленное значение преобразуется в соответствующий тип с плавающей точкой.

Целочисленные преобразования

Целочисленное преобразование (integral promotion) преобразовывает значения малых целочисленных типов в большие. Типы bool, char, signed char, unsigned char, short и unsigned short преобразуются в int, если значение соответствует ему, а в противном случае оно преобразуется в тип unsigned int. Как уже неоднократно упоминалось, значение false типа bool преобразуется в 0, a true в 1.

Большие символьные типы (wchar_t, char16_t и char32_t) преобразуются в наименьший целочисленный тип int, unsigned int, long, unsigned long, long long или unsigned long long, которому соответствуют все возможные значения этого символьного типа.

Операнды беззнакового типа

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

Как обычно, сначала осуществляются целочисленные преобразования. Если полученные в результате типы совпадают, то никаких дальнейших преобразований не нужно. Если оба (возможно преобразованных) операнда имеют одинаковый знак, то операнд с меньшим типом преобразуется в больший тип.

При разных знаках, если тип беззнакового операнда больший, чем у знакового операнда, знаковый операнд преобразуется в беззнаковый. Например, при операторах типа unsigned int и int, int преобразуется в unsigned int. Следует заметить, что если значение типа int отрицательное, результат преобразуется так, как описано в разделе 2.1.2.

Остается случай, когда тип знакового операнда больше, чем беззнакового. В данном случае результат зависит от конкретной машины. Если все значения беззнакового типа соответствуют большему типу, то операнд беззнакового типа преобразуется в знаковый. Если значения не соответствуют, то знаковый операнд преобразуется в беззнаковый. Например, если операнды имеют типы long и unsigned int и размер у них одинаковый, операнд типа long будет преобразован в unsigned int. Если тип long окажется больше, то unsigned int будет преобразован в long.

Концепция арифметических преобразований

Арифметические преобразования проще всего изучить на примерах.

bool flag; char cval;

short sval; unsigned short usval;

int ival; unsigned int uival;

long lval; unsigned long ulval;

float fval; double dval;

3.14159L + 'a'; // 'a' преобразуется в int, а затем int в long double

dval + ival;  // ival преобразуется в double

dval + fval;  // fval преобразуется в double

ival = dval;  // dval преобразуется в int (с усечением)

flag = dval;  // если dval - 0, flag - false, в противном случае - true

cval + fval;  // cval преобразуется в int, затем int во float

sval + cval;  // sval и cval преобразуется в int

cval + lval;  // cval преобразуется в long

ival + ulval; // ival преобразуется в unsigned long

usval + ival; // преобразование зависит от соотношения

              // размеров типов unsigned short и int

uival + lval; // преобразование зависит от соотношения

              // размеров типов unsigned int и long

В первом выражении суммы символьная константа 'a' имеет тип char, являющийся числовым (см. раздел 2.1.1). Какое именно это значение, зависит от используемого машиной набора символов. На машине авторов, где установлен набор символов ASCII, символу 'a' соответствует число 97. При добавлении символа 'a' к значению типа long double значение типа char преобразуется в тип int, а затем в тип long double. Это преобразованное значение добавляется к литералу. Интересны также два последних случая, где происходит преобразование беззнаковых значений. Тип результата этих выражений зависит от конкретной машины.

Упражнения раздела 4.11.1

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

(a) if (fval)  (b) dval = fval + ival;  (c) dval + ival * cval;

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

Упражнение 4.35. С учетом определений

char cval;  int ival;   unsigned int ui;

float fval; double dval;

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

(a) cval = 'a' + 3;    (b) fval = ui - ival * 1.0;

(с) dval = ui * fval;  (d) cval = ival + fval + dval;

 

4.11.2. Другие неявные преобразования

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

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

int ia[10];   // массив из десяти целых чисел

int* ip = ia; // ia преобразуется в указатель на первый элемент

Это преобразование не происходит при использовании массива в выражении decltype или в качестве операнда операторов обращения к адресу (&), sizeof или typeid (который рассматривается в разделе 19.2.2). Преобразование не происходит также при инициализации ссылки на массив (см. раздел 3.5.1). Подобное преобразование указателя происходит при использовании в выражении типа функции, как будет описано в разделе 6.7.

Преобразование указателя. Существует несколько других преобразований указателя: постоянное целочисленное значение 0 и литерал nullptr могут быть преобразованы в указатель на любой тип; указатель на любой неконстантный тип может быть преобразован в void*, а указатель на любой тип может быть преобразован в const void*. Как будет продемонстрировано в разделе 15.2.2, существуют дополнительные преобразования указателя, относящиеся к типам, связанным наследованием.

Преобразование в тип bool . Существует автоматическое преобразование арифметических типов и типов указателя в тип bool. Если указатель или арифметическое значение — нуль, преобразование возвращает значение false; любое другое значение возвращает true:

char *cp = get_string();

if (cp) /* ... */     // true, если cp не нулевой указатель

while (*cp) /* ... */ // true, если *cp не нулевой символ

Преобразование в константу. Указатель на неконстантный тип можно преобразовать в указатель на соответствующий константный тип, то же относится и к ссылкам. Таким образом, если Т — тип, то указатель или ссылку на тип T можно преобразовать в указатель или ссылку на const Т (см. разделы 2.4.1 и 2.4.2).

int i;

const int &j = i;   // преобразовать в ссылку на const int

const int *p = &i;  // преобразовать неконстантный адрес в константный

int &r = j, *q = p; // ошибка: преобразование константы в не константу

                    // недопустимо

Обратное преобразование (устранение спецификатора const нижнего уровня) невозможно.

Преобразование, определенное типами класса. Тип класса может сам определять преобразования, которые компилятор применит автоматически. Компилятор применяет только одно преобразование типа класса за раз. В разделе 7.5.4 приведен пример, когда необходимо несколько преобразований, и он не работает.

В программах ранее уже использовались преобразования типов класса, когда символьная строка в стиле С использовалась там, где ожидался библиотечный тип string (см. раздел 3.5.5), а также при чтении из потока istream в условии.

string s, t = "a value"; // с имвольный строковый литерал преобразован

                         // в тип string

while (cin >> s)         // условие while преобразует cin в bool

Условие (cin >> s) читает поток cin и возвращает его же как результат. Условия ожидают значение типа bool, но оно проверяет значение типа istream. Библиотека IO определяет преобразование из типа istream в bool. Это преобразование используется автоматически, чтобы преобразовать поток cin в тип bool. Результирующее значение типа bool зависит от состояния потока. Если последнее чтение успешно, то преобразование возвращает значение true. Если последняя попытка потерпела неудачу, то преобразование возвращает значение false.

 

4.11.3. Явные преобразования

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

int i, j;

double slope = i/j;

Для этого необходим способ явного преобразования переменных i и/или j в тип double. Для явного преобразования используется приведение (cast) типов.

Хотя приведение время от времени необходимо, оно довольно опасно.

Именованные операторы приведения

Именованный оператор приведения имеет следующую форму:

имя_приведения < тип >( выражение );

где тип — это результирующий тип преобразования, а выражение — приводимое значение. Если тип — ссылка, то результат l-значение. Имя_приведения может быть одним из следующих: static_cast, dynamic_cast, const_cast и reinterpret_cast. Приведение dynamic_cast, обеспечивающее идентификацию типов времени выполнения, рассматривается в разделе 19.2. Имя_приведения определяет, какое преобразование осуществляется.

Оператор static_cast

Любое стандартное преобразование типов, кроме задействующего спецификатор const нижнего уровня, можно затребовать, используя оператор static_cast. Например, приведя тип одного из операндов к типу double, можно заставить выражение использовать деление с плавающей точкой:

// приведение для вынужденного деления с плавающей точкой

double slope = static_cast(j) / i;

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

Оператор static_cast полезен также при выполнении преобразований, которые компилятор не выполняет автоматически. Например, его можно использовать для получения значения указателя, сохраняемого в указателе void* (см. раздел 2.3.2):

void* p = &d; // ok: адрес любого неконстантного объекта может

              //  храниться в указателе void*

// ok: преобразование void* назад в исходный тип указателя

double *dp = static_cast(p);

После сохранения адреса в указателе типа void* можно впоследствии использовать оператор static_cast и привести указатель к его исходному типу, что позволит сохранить значение указателя. Таким образом, результат приведения будет равен первоначальному значению адреса. Однако следует быть абсолютно уверенным в том, что тип, к которому приводится указатель, является фактическим типом этого указателя; при несоответствии типов результат непредсказуем.

Оператор const_cast

Оператор const_cast изменяет только спецификатор const нижнего уровня своего операнда (см. раздел 2.4.3):

const char *pc;

char *p = const_cast(pc); // ok: однако запись при помощи p

                                 // указателя непредсказуема

Принято говорить, что приведение, преобразующее константный объект в неконстантный, "сбрасывает const". При сбросе константности объекта компилятор больше не будет препятствовать записи в этот объект. Если объект первоначально не был константным, использование приведения для доступа на запись вполне допустимо. Но применение оператора const_cast для записи в первоначально константный объект непредсказуемо.

Только оператор const_cast позволяет изменить константность выражения. Попытка изменить константность выражения при помощи любого другого именованного оператора приведения закончится ошибкой компиляции. Аналогично нельзя использовать оператор const_cast для изменения типа выражения:

const char *cp;

// ошибка: static_cast не может сбросить const

char *q = static_cast(cp);

static_cast(cp); // ok: преобразует строковый литерал в строку

const_cast(cp);  // ошибка: const_cast изменяет только

                         // константность

Оператор const_cast особенно полезен в контексте перегруженных функций, рассматриваемых в разделе 6.4.

Оператор reinterpret_cast

Оператор reinterpret_cast осуществляет низкоуровневую интерпретацию битовой схемы своих операндов. Рассмотрим, например, следующее приведение:

int *ip;

char *pc = reinterpret_cast(ip);

Никогда не следует забывать, что фактическим объектом, на который указывает указатель pc, является целое число, а не символ. Любое использование указателя pc, подразумевающее, что это обычный символьный указатель, вероятно, потерпит неудачу во время выполнения. Например, следующий код, вероятней всего, приведет к непредвиденному поведению во время выполнения:

string str(pc);

Использование указателя pc для инициализации объекта типа string — хороший пример небезопасности оператора reinterpret_cast. Проблема в том, что при изменении типа компилятор не выдаст никаких предупреждений или сообщений об ошибке. При инициализации указателя pc адресом типа int компилятор не выдаст ни предупреждения, ни сообщения об ошибке, поскольку явно указано, что это и нужно. Однако любое последующее применение указателя pc подразумевает, что он содержит адрес значения типа char*. Компилятор не способен выяснить, что фактически это указатель на тип int. Таким образом, инициализация строки str при помощи указателя pc вполне правомерна, хотя в данном случае абсолютно бессмысленна, если не хуже! Отследить причину такой проблемы иногда чрезвычайно трудно, особенно если приведение указателя ip к pc происходит в одном файле, а использование указателя pc для инициализации объекта класса string — в другом.

Оператор reinterpret_cast жестко зависит от конкретной машины. Чтобы безопасно использовать оператор reinterpret_cast, следует хорошо понимать, как именно реализованы используемые типы, а также то, как компилятор осуществляет приведение.

Приведение типов в старом стиле

В ранних версиях языка С++ явное приведение имело одну из следующих двух форм:

тип ( выражение ); // форма записи приведения в стиле функции

( тип ) выражение ; // форма записи приведения в стиле языка С

В зависимости от используемых типов, приведение старого стиля срабатывает аналогично операторам const_cast, static_cast или reinterpret_cast. В случаях, где используются операторы static_cast или const_cast, приведение типов в старом стиле позволяет осуществить аналогичное преобразование, что и соответствующий именованный оператор приведения. Но если ни один из подходов не допустим, то приведение старого стиля срабатывает аналогично оператору reinterpret_cast. Например, используя форму записи старого стиля, можно получить тот же результат, что и с использованием reinterpret_cast.

char *pc = (char*) ip; // ip указатель на тип int

Совет. Избегайте приведения типов

Приведение нарушает обычный порядок контроля соответствия типов (см. раздел 2.2), поэтому авторы настоятельно рекомендуют избегать приведения типов. Это особенно справедливо для оператора reinterpret_cast . Такие приведения всегда опасны. Операторы const_cast могут быть весьма полезны в контексте перегруженных функций, рассматриваемых в разделе 6.4. Использование оператора const_cast зачастую свидетельствует о плохом проекте. Другие операторы приведения, static_cast и dynamic_cast , должны быть необходимы нечасто. При каждом применении приведения имеет смысл хорошо подумать, а нельзя ли получить тот же результат другим способом. Если приведение все же неизбежно, имеет смысл принять меры, позволяющие снизить вероятность возникновения ошибки, т.е. ограничить область видимости, в которой используется приведенное значение, а также хорошо документировать все подобные случаи.

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

Упражнения раздела 4.11.3

Упражнение 4.36. С учетом того, что i имеет тип int, a d — double, напишите выражение i *= d так, чтобы осуществлялось целочисленное умножение, а не с плавающей запятой.

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

int i; double d; const string *ps; char *pc; void *pv;

(a) pv = (void*)ps; (b) i = int(*pc);

(c) pv = &d;        (d) pc = (char*)pv;

Упражнение 4.38. Объясните следующее выражение:

double slope = static_cast(j/i);

 

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

 

5.3.1. Оператор

if

Операторif выполняет один из двух операторов в зависимости от истинности своего условия. Существуют две формы оператора if: с разделом else и без него. Синтаксис простой формы оператора if имеет следующий вид:

if ( условие )

 оператор

Оператор if else имеет следующую форму:

if ( условие )

  оператор

else

  оператор2

В обеих версиях условие заключается в круглые скобки. Условие может быть выражением или инициализирующим объявлением переменной (см. раздел 5.2). Тип выражения или переменной должен быть преобразуем в тип bool (см. раздел 4.11). Как обычно, и оператор , и оператор2 могут быть блоком.

Если условие истинно, оператор выполняется. По завершении оператора выполнение продолжается после оператора if.

Если условие ложно, оператор пропускается. В простом операторе if выполнение продолжается после оператора if, а в операторе if else выполняется оператор2 .

Использование оператора if else

Для иллюстрации оператора if else вычислим символ оценки по ее числу. Подразумевается, что числовые значения оценок находятся в диапазоне от нуля до 100 включительно. Оценка 100 получает знак "А++", оценка ниже 60 — "F", а остальные группируются по десять: от 60 до 69 — "D", от 70 до 79 — "C" и т.д. Для хранения возможных символов оценок используем вектор:

vector scores = {"F", "D", "C", "B", "A", "А++"};

Для решения этой проблемы можно использовать оператор if else, чтобы выполнять разные действия проходных и не проходных отметок.

// если оценка меньше 60 - это F, в противном случае вычислять индекс

string lettergrade;

if (grade < 60)

 lettergrade = scores[0];

else

 lettergrade = scores[(grade - 50)/10];

В зависимости от значения переменной grade оператор выполняется либо после части if, либо после части else. В части else вычисляется индекс оценки уже без неудовлетворительных. Затем усекающее остаток целочисленное деление (см. раздел 4.2) используется для вычисления соответствующего индекса вектора scores.

Вложенные операторы if

Чтобы сделать программу интересней, добавим к удовлетворительным отметкам плюс или минус. Плюс присваивается оценкам, заканчивающимся на 8 или 9, а минус — заканчивающимся на 0, 1 или 2.

if (grade % 10 > 7)

 lettergrade += '+'; // оценки, заканчивающиеся на 8 или 9, получают +

else if (grade % 10 < 3)

 lettergrade += '-'; // оценки, заканчивающиеся на 0, 1 и 2, получают -

Для получения остатка и принятия на основании его решения, добавлять ли плюс или минус, используем оператор деления по модулю (см. раздел 4.2).

Теперь добавим код, присваивающий плюс или минус, к коду, выбирающему символ оценки:

// если оценка неудовлетворительна, нет смысла проверять ее на + или -

if (grade < 60)

 lettergrade = scores[0];

else {

 lettergrade = scores[(grade - 50)/10]; // выбрать символ оценки

if (grade != 100) // добавлять + или -, только если это не А++

 if (grade % 10 > 7)

  lettergrade += '+'; // оценки, заканчивающиеся на 8 или 9,

                      // получают +

 else if (grade % 10 < 3)

  lettergrade += '-'; // оценки, заканчивающиеся на 0, 1 и 2,

                      // получают -

}

Обратите внимание, что два оператора, следующих за первым оператором else, заключены в блок. Если переменная grade содержит значение 60 или больше, возможны два действия: выбор символа оценки из вектора scores и, при условии, добавление плюса или минуса.

Следите за фигурными скобками

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

if (grade < 60)

 lettergrade = scores[0];

else // ошибка: отсутствует фигурная скобка

 lettergrade = scores[(grade - 50)/10];

 // несмотря на внешний вид, без фигурной скобки, этот код

 // выполняется всегда

 // неудовлетворительным оценкам ошибочно присваивается - или +

 if (grade != 100)

  if (grade % 10 > 7)

   lettergrade += '+'; // оценки, заканчивающиеся на 8 или 9,

                       // получают +

  else if (grade % 10 < 3)

   lettergrade += '-'; // оценки, заканчивающиеся на 0, 1 и 2,

                       // получают -

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

Во избежание подобных проблем некоторые стили программирования рекомендуют всегда использовать фигурные скобки после оператора if или else (а также вокруг тел циклов while и for).

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

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

Потерянный оператор else

Когда один оператор if вкладывается в другой, ветвей if может оказаться больше, чем ветвей else. Действительно, в нашей программе оценивания четыре оператора if и два оператора else. Возникает вопрос: как установить, которому оператору if принадлежит данный оператор else?

Эта проблема, обычно называемая потерянным оператором else (dangling else), присуща многим языкам программирования, предоставляющим операторы if и if else. Разные языки решают эту проблему по-разному. В языке С++ неоднозначность решается так: оператор else принадлежит ближайшему расположенному выше оператору if без else.

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

// Ошибка: порядок выполнения НЕ СООТВЕТСТВУЕТ отступам; ветвь else

// принадлежит внутреннему if

if (grade % 10 >= 3)

 if (grade % 10 > 7)

  lettergrade += '+'; // оценки, заканчивающиеся на 8 или 9,

                      // получают +

else

 lettergrade += '-';  // оценки, заканчивающиеся на 3, 4, 5, 6,

                      // получают - !

Отступ в данном коде подразумевает, что оператор else предназначен для внешнего оператора if, т.е. он выполняется, когда значение grade заканчивается цифрой меньше 3. Однако, несмотря на наши намерения и вопреки отступу, ветвь else является частью внутреннего оператора if. Этот код добавляет '-' к оценкам, заканчивающимся на 3-7 включительно! Правильно выровненный, в соответствии с правилами выполнения, этот код выглядел бы так:

// отступ соответствует порядку выполнения,

//  но не намерению программиста

if (grade % 10 >= 3)

 if (grade % 10 > 7)

  lettergrade += '+'; // оценки, заканчивающиеся на 8 или 9,

                      // получают +

 else

  lettergrade += '-'; // оценки, заканчивающиеся на 3, 4, 5, 6,

                      // получают - !

Контроль пути выполнения при помощи фигурных скобок

Заключив внутренний оператор if в блок, можно сделать ветвь else частью внешнего оператора if:

// добавлять плюс для оценок, заканчивающихся на 8 или 9, а минус для

// заканчивающихся на 0, 1 или 2

if (grade % 10 >= 3) {

 if (grade % 10 > 7)

  lettergrade += '+'; // оценки, заканчивающиеся на 8 или 9,

                      // получают +

} else                // скобки обеспечивают else для внешнего if

 lettergrade += '-';  // оценки, заканчивающиеся на 0, 1 и 2,

                      // получают -

Операторы не распространяются за границы блока, поэтому внутренний цикл if заканчивается на закрывающей фигурной скобке перед оператором else. Оператор else не может быть частью внутреннего оператора if. Теперь ближайшим свободным оператором if оказывается внешний, как и предполагалось изначально.

Упражнения раздела 5.3.1

Упражнение 5.5. Напишите собственную версию программы преобразования числовой оценки в символ с использованием оператора if else.

Упражнение 5.6. Перепишите программу оценки так, чтобы использовать условный оператор (см. раздел 4.7) вместо оператора if else.

Упражнение 5.7. Исправьте ошибки в каждом из следующих фрагментов кода:

(a) if (ival1 != ival2)

     ival1 = ival2

    else ival1 = ival2 = 0;

(b) if (ival < minval)

     minval = ival;

     occurs = 1;

(c) if (int ival = get_value())

     cout << "ival = " << ival << endl;

    if (!ival)

     cout << "ival = 0\n";

(d) if (ival = 0)

     ival = get_value();

Упражнение 5.8. Что такое "потерянный оператор else"? Как в языке С++ определяется принадлежность ветви else?

 

5.3.2. Оператор

switch

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

• Читать каждый введенный символ.

• Сравнить каждый символ с набором искомых гласных.

• Если символ соответствует одной из гласных букв, добавить 1 к соответствующему счетчику.

• Отобразить результаты.

Программа должна отобразить результаты в следующем виде:

Number of vowel а: 3195

Number of vowel e: 6230

Number of vowel i: 3102

Number of vowel o: 3289

Number of vowel u: 1033

Для непосредственного решения этой задачи можно использовать оператор switch.

// инициализировать счетчики для каждой гласной

unsigned aCnt = 0, eCnt = 0, iCnt = 0, oCnt = 0, uCnt = 0;

char ch;

while (cin >> ch) {

 // если ch - гласная, увеличить соответствующий счетчик

 switch (ch) {

 case 'a':

  ++aCnt;

  break;

 case 'e':

  ++eCnt;

  break;

 case 'i':

  ++iCnt;

  break;

 case 'o':

  ++oCnt;

  break;

 case 'u':

  ++uCnt;

  break;

 }

}

// вывод результата

cout << "Number of vowel a: \t" << aCnt << '\n'

     << "Number of vowel e: \t" << eCnt << '\n'

     << "Number of vowel i: \t" << iCnt << '\n'

     << "Number of vowel o: \t" << oCnt << '\n'

     << "Number of vowel u: \t" << uCnt << endl;

Оператор switch вычисляет результат выражения, расположенного за ключевым словом switch. Это выражение может быть объявлением инициализированной переменной (см. раздел 5.2). Выражение преобразуется в целочисленный тип. Результат выражения сравнивается со значением, ассоциированным с каждым оператором case.

Если результат выражения соответствует значению метки case, выполнение кода начинается с первого оператора после этой метки. В принципе выполнение кода продолжается до конца оператора switch, но оно может быть прервано оператором break.

Более подробно оператор break рассматривается в разделе 5.5.1, а пока достаточно знать, что он прерывает текущий поток выполнения. В данном случае оператор break передает управление первому оператору после оператора switch. Здесь оператор switch является единственным оператором в теле цикла while, поэтому его прерывание возвращает контроль окружающему оператору while. Поскольку в нем нет никаких других операторов, цикл while продолжается, если его условие выполняется.

Если соответствия не найдено, выполнение сразу переходит к первому оператору после switch. Как уже упоминалось, в этом примере выход из оператора switch передает управление условию цикла while.

Ключевое слово case и связанное с ним значение называют также меткой case (case label). Значением каждой метки case является константное выражение (см. раздел 2.4.4).

char ch = getVal();

int ival = 42;

switch(ch) {

case 3.14: // ошибка: метка case не целое число

case ival: // ошибка: метка case не константа

// ...

Одинаковые значения меток case недопустимы. Существует также специальная метка default, рассматриваемая ниже.

Порядок выполнения в операторе switch

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

Однако возможны ситуации, когда необходимо именно стандартное поведение оператора switch. У каждой метки case может быть только одно значение, однако две или более метки могут совместно использовать единый набор действий. В таких ситуациях достаточно пропустить оператор break и позволить программе пройти несколько меток case.

Например, можно было бы посчитать общее количество гласных так:

unsigned vowelCnt = 0;

// ...

switch (ch) {

// для инкремента vowelCnt подойдет любая буква а, е, i, о или u

case 'a':

case 'e':

case 'i':

case 'o':

case 'u':

 ++vowelCnt;

 break;

}

Здесь расположено несколько меток case подряд без оператора break. Теперь при любой гласной в переменной ch будет выполняться тот же код.

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

switch (ch) {

// альтернативный допустимый синтаксис

case 'a': case 'e': case 'i': case 'o': case 'u':

 ++vowelCnt;

 break;

}

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

Пропуск оператора break — весьма распространенная ошибка

Весьма распространено заблуждение, что выполняются только те операторы, которые связаны с совпавшей меткой case. Вот пример неправильной реализации подсчета гласных в операторе switch:

// внимание: преднамеренно неправильный код!

switch (ch) {

case 'a' :

 ++aCnt; // Упс! Необходим оператор break

case 'e':

 ++eCnt; // Упс! Необходим оператор break

case 'i':

 ++iCnt; // Упс! Необходим оператор break

case 'o':

 ++oCnt; // Упс! Необходим оператор break

case 'u':

 ++uCnt;

}

Чтобы понять происходящее, предположим, что значением переменной ch является 'e'. Выполнение переходит к коду после метки case 'e', где происходит инкремент переменной eCnt. Выполнение продолжается далее через метки case, увеличивая также значения переменных iCnt, oCnt и uCnt.

Несмотря на то что оператор break и не обязателен после последней метки оператора switch, использовать его все же рекомендуется. Ведь если впоследствии оператор switch будет дополнен еще одной меткой case, отсутствие оператора break после прежней последней метки не создаст проблем.

Метка default

Операторы после метки default выполняются, если ни одна из меток case не соответствует значению выражения оператора switch. Например, в рассматриваемый код можно добавить счетчик негласных букв. Значение этого счетчика по имени otherCnt будет увеличиваться в случае default:

// если ch гласная, увеличить соответствующий счетчик

switch (ch) {

case 'a': case 'e': case 'i': case 'o': case 'u':

 ++vowelCnt;

 break;

default:

 ++otherCnt;

 break;

}

В этой версии, если переменная ch не содержит гласную букву, управление перейдет к метке default и увеличится значение счетчика otherCnt.

Раздел default имеет смысл создавать всегда, даже если в нем не происходит никаких действий. Впоследствии это однозначно укажет читателю кода, что случай default не был забыт, т.е. для остальных случаев никаких действий предпринимать не нужно.

Метка не может быть автономной; она должна предшествовать оператору или другой метке case. Если оператор switch заканчивается разделом default, в котором не осуществляется никаких действий, за меткой default должен следовать пустой оператор или пустой блок.

Определение переменной в операторе switch

Как уже упоминалось, выполнение оператора switch способно переходить через метки case. Когда выполнение переходит к некой метке case, весь расположенный выше код оператора switch будет проигнорирован. Факт игнорирования кода поднимает интересный вопрос: что будет, если пропущенный код содержит определение переменной?

Ответ прост: недопустим переход с места, где переменная с инициализатором уже вышла из области видимости к месту, где эта переменная находится в области видимости.

case true:

 // этот оператор switch недопустим, поскольку инициализацию

 // можно обойти

 string file_name; // ошибка: выполнение обходит неявно

                   // инициализированную переменную

 int ival = 0;     // ошибка: выполнение обходит неявно

                   // инициализированную переменную

 int jval;         // ok: поскольку jval не инициализирована

 break;

case false:

 // ok: jval находится в области видимости, но она не инициализирована

 jval = next_num();     // ok: присвоить значение jval

 if (file_name.empty()) // file_name находится в области видимости, но

                        // она не инициализирована

 // ...

Если бы этот код был допустим, то любой переход к случаю false обходил бы инициализацию переменных file_name и ival, но они оставались бы в области видимости и код вполне мог бы использовать их. Однако эти переменные не были бы инициализированы. В результате язык не позволяет перепрыгивать через инициализацию, если инициализированная переменная находится в области видимости в пункте, к которому переходит управление.

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

case true:

 {

  // ok : оператор объявления в пределах операторного блока

  string file_name = get_file_name();

  // ...

 }

 break;

case false:

 if (file_name.empty()) // ошибка: file_name вне области видимости

Упражнения раздела 5.3.2

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

Упражнение 5.10. Программа подсчета гласных имеет одну проблему: она не учитывает заглавные буквы как гласные. Напишите программу, которая подсчитывает гласные буквы как в верхнем, так и в нижнем регистре. То есть значение счетчика aCnt должно увеличиваться при встрече как символа 'a', так и символа 'A' (аналогично для остальных гласных букв).

Упражнение 5.11. Измените рассматриваемую программу так, чтобы она подсчитывала также количество пробелов, символов табуляции и новой строки.

Упражнение 5.12. Измените рассматриваемую программу так, чтобы она подсчитывала количество встреченных двухсимвольных последовательностей: ff, fl и fi.

Упражнение 5.13. Каждая из приведенных ниже программ содержит распространенную ошибку. Выявите и исправьте каждую из них.

Код для упражнения 5.13

(a) unsigned aCnt = 0, eCnt = 0, iouCnt = 0;

    char ch = next_text();

    switch (ch) {

    case 'a': aCnt++;

    case 'e': eCnt++;

    default: iouCnt++;

    }

(b) unsigned index = some_value();

    switch (index) {

    case 1:

     int ix = get_value();

     ivec[ix] = index;

     break;

    default:

     ix = ivec.size()-1;

     ivec[ix] = index;

(c) unsigned evenCnt = 0, oddCnt = 0;

    int digit = get_num() % 10;

    switch (digit) {

    case 1, 3, 5, 7, 9:

     oddcnt++;

     break;

    case 2, 4, 6, 8, 10:

     evencnt++;

     break;

    }

(d) unsigned ival=512, jval=1024, kval=4096;

    unsigned bufsize;

    unsigned swt = get_bufCnt();

    switch(swt) {

    case ival:

     bufsize = ival * sizeof (int);

     break;

    case jval:

     bufsize = jval * sizeof(int);

     break;

    case kval:

     bufsize = kval * sizeof(int);

     break;

    }

 

Итерационные операторы (iterative statement), называемые также циклами (loop), обеспечивают повторное выполнение кода, пока их условие истинно. Операторы while и for проверяют условие прежде, чем выполнить тело. Оператор do while сначала выполняет тело, а затем проверяет свое условие.

 

5.4.1. Оператор

while

Операторwhile многократно выполняет оператор, пока его условие остается истинным. Его синтаксическая форма имеет следующий вид:

while ( условие )

  оператор

Пока условие истинно (значение true), оператор (который зачастую является блоком кода) выполняется. Условие не может быть пустым. Если при первой проверке условие ложно (значение false), оператор не выполняется.

Условие может быть выражением или объявлением инициализированной переменной (см. раздел 5.2). Обычно либо само условие, либо тело цикла должно делать нечто изменяющее значение выражения. В противном случае цикл никогда не закончится.

Переменные, определенные в условии или теле оператора while, создаются и удаляются при каждой итерации.

Использование цикла while

Цикл while обычно используется в случае, когда итерации необходимо выполнять неопределенное количество раз, например, при чтении ввода. Цикл while полезен также при необходимости доступа к значению управляющей переменной после завершения цикла. Рассмотрим пример.

vector v;

int i;

// читать до конца файла или отказа ввода

while (cin >> i)

 v.push_back(i); // найти первый отрицательный элемент

auto beg = v.begin();

while (beg != v.end() && *beg >= 0)

 ++beg;

if (beg == v.end())

 // известно, что все элементы v больше или равны нулю

Первый цикл читает данные со стандартного устройства ввода. Он может выполняться сколько угодно раз. Условие становится ложно, когда поток cin читает недопустимые данные, происходит ошибка ввода или встречается конец файла. Второй цикл продолжается до тех пор, пока не будет найдено отрицательное значение. Когда цикл заканчивается, переменная beg будет либо равна v.end(), либо обозначит элемент вектора v, значение которого меньше нуля. Значение переменной beg можно использовать вне цикла while для дальнейшей обработки.

Упражнения раздела 5.4.1

Упражнение 5.14. Напишите программу для чтения строк со стандартного устройства ввода и поиска совпадающих слов. Программа должна находить во вводе места, где одно слово непосредственно сопровождается таким же. Отследите наибольшее количество повторений и повторяемое слово. Отобразите максимальное количество дубликатов или сообщение, что никаких повторений не было. Например, при вводе how now now now brown cow cow вывод должен указать, что слово now встретилось три раза.

 

5.4.2. Традиционный оператор

for

Операторfor имеет следующий синтаксис:

for ( инициализирующий-оператор условие ; выражение )

  оператор

Слово for и часть в круглых скобках зачастую упоминают как заголовок for (for header).

Инициализирующий-оператор должен быть оператором объявления, выражением или пустым оператором. Каждый из этих операторов завершается точкой с запятой, поэтому данную синтаксическую форму можно рассматривать так:

for ( инициализатор ; условие ; выражение )

  оператор

Как правило, инициализирующий-оператор используется для инициализации или присвоения исходного значения переменной, изменяемой в цикле. Для управления циклом служит условие . Пока условие истинно, оператор выполняется. Если при первой проверке условие оказывается ложным, оператор не выполняется ни разу. Для изменения значения переменной, инициализированной в инициализирующем операторе и проверяемой в условии, используется выражение . Оно выполняется после каждой итерации цикла. Как и в других случаях, оператор может быть одиночным оператором или блоком операторов.

Поток выполнения в традиционном цикле for

Рассмотрим следующий цикл for из раздела 3.2.3:

// обрабатывать символы,

//  пока они не исчерпаются или не встретится пробел

for (decltype(s.size()) index = 0;

     index != s.size () && !isspace(s[index]); ++index)

 s[index] = toupper(s[index]); // преобразовать в верхний регистр

Порядок его выполнения таков.

1. В начале цикла только однажды выполняется инициализирующий-оператор . В данном случае определяется переменная index и инициализируется нулем.

2. Затем обрабатывается условие . Если index не равен s.size() и символ в элементе s[index] не является пробелом, то выполняется тело цикла for. В противном случае цикл заканчивается. Если условие ложно уже на первой итерации, то тело цикла for не выполняется вообще.

3. Если условие истинно, то тело цикла for выполняется. В данном случае оно переводит символ в элементе s[index] в верхний регистр.

4. И наконец, обрабатывается выражение . В данном случае значение переменной index увеличивается 1.

Эти четыре этапа представляют первую итерацию цикла for. Этап 1 выполняется только однажды при входе в цикл. Этапы 2–4 повторяются, пока условие не станет ложно, т.е. пока не встретится символ пробела в элементе s или пока index не превысит s.size().

Не забывайте, что видимость любого объекта, определенного в пределах заголовка for, ограничивается телом цикла for. Таким образом, в данном примере переменная index недоступна после завершения цикла for.

Несколько определений в заголовке for

Подобно любому другому объявлению, инициализирующий-оператор способен определить несколько объектов. Однако только инициализирующий-оператор может быть оператором объявления. Поэтому у всех переменных должен быть тот же базовый тип (см. раздел 2.3). Для примера напишем цикл, дублирующий элементы вектора в конец следующим образом:

// запомнить размер v и остановиться,

//  достигнув первоначально последнего элемента

for (decltype(v.size()) i = 0, sz = v.size(); i != sz; ++i)

 v.push_back(v[i]);

В этом цикле инициализирующий-оператор определяется индекс i и управляющая переменная цикла sz.

Пропуск частей заголовка for

В заголовке for может отсутствовать любой (или все) элемент: инициализирующий-оператор , условие или выражение .

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

auto beg = v.begin();

for ( /* ничего */; beg != v.end() && *beg >= 0; ++beg)

 ; // ничего не делать

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

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

for (int i = 0; /* нет условия */ ; ++i) {

 // обработка i; код в цикле должен остановить итерацию!

}

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

vector v;

for (int i; cin >> i; /* нет выражения */ )

 v.push_back(i);

В этом цикле нет никакой необходимости в выражении, поскольку условие изменяет значение переменной i. Условие проверяет входной поток, поэтому цикл заканчивается, когда прочитан весь ввод или произошла ошибка ввода.

Упражнения раздела 5.4.2

Упражнение 5.15. Объясните каждый из следующих циклов. Исправьте все обнаруженные ошибки.

(a) for (int ix = 0; ix != sz; ++ix) { /* ... */ }

    if (ix != sz)

     // ...

(b) int ix;

    for (ix != sz; ++ix) { /* ... */ }

(c) for (int ix = 0; ix != sz; ++ix, ++sz) { /* ... */ }

Упражнение 5.16. Цикл while особенно хорош, когда необходимо выполнить некое условие; например, когда нужно читать значения до конца файла. Цикл for считают циклом пошагового выполнения: индекс проходит диапазон значений в коллекции. Напишите идиоматическое использование каждого цикла, а затем перепишите каждый случаи использования в другой конструкции цикла. Если бы вы могли использовать только один цикл, то какой бы вы выбрали и почему?

Упражнение 5.17. Предположим, есть два вектора целых чисел. Напишите программу, определяющую, не является ли один вектор префиксом другого. Для векторов неравной длины сравнивайте количество элементов меньшего вектора. Например, если векторы содержат значения 0, 1, 1, 2 и 0, 1, 1, 2, 3, 5, 8 соответственно, ваша программа должна возвратить true.

 

5.4.3. Серийный оператор

for

Новый стандарт ввел упрощенный оператор for, который перебирает элементы контейнера или другой последовательности. Синтаксис серийного оператора for (range for) таков:

for ( объявление : выражение )

  оператор

выражение должно представить некую последовательность, такую, как список инициализации (см. раздел 3.3.1), массив (см. раздел 3.5), или объект такого типа, как vector или string, у которого есть функции-члены begin() и end(), возвращающие итераторы (см. раздел 3.4).

объявление определяет переменную. Каждый элемент последовательности должен допускать преобразование в тип переменной (см. раздел 4.11). Проще всего гарантировать соответствие типов за счет использования спецификатора типа auto (см. раздел 2.5.2). Так компилятор выведет тип сам. Если необходима запись в элементы последовательности, то переменная цикла должна иметь ссылочный тип.

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

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

vector v = {0,1,2,3,4,5,6,7,8,9};

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

for (auto &r : v) // для каждого элемента вектора v

 r *= 2;          // удвоить значение каждого элемента вектора v

Заголовок for объявляет, что управляющая переменная цикла r связана с вектором v. Чтобы позволить компилятору самостоятельно вывести тип переменной r, используем спецификатор auto. Поскольку предполагается изменение значений элементов вектора v, объявим переменную r как ссылку. При присвоении ей значений в цикле фактически присваивается значение элементу, с которым связана переменная r в данный момент.

Вот эквивалентное определение серийного оператора for в терминах традиционного цикла for:

for (auto beg = v.begin(), end = v.end(); beg != end; ++beg) {

 auto &r = *beg; // для изменения элементов r должна быть ссылкой

 r *= 2;         // удвоить значение каждого элемента вектора v

}

Теперь, когда известно, как работает серийный оператор for, можно понять, почему в разделе 3.3.2 упоминалось о невозможности его использования для добавления элементов к вектору или другому контейнеру. В серийном операторе for кешируется значение end(). Если добавить или удалить элементы из последовательности, сохраненное значение end() станет неверным (см. раздел 3.4.1). Более подробная информация по этой теме приведена в разделе 9.3.6.

 

5.4.4. Оператор

do while

Операторdo while похож на оператор while, но его условие проверяется после выполнения тела. Независимо от значения условия тело цикла выполняется по крайней мере однажды. Его синтаксическая форма приведена ниже.

do

  оператор

while (условие);

После заключенного в скобки условия оператор do while заканчивается точкой с запятой.

В цикле do while оператор выполняется прежде, чем условие . Причем условие не может быть пустым. Если условие ложно, цикл завершается, в противном случае цикл повторяется. Используемые в условии переменные следует определить вне тела оператора do while.

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

// многократно запрашивать у пользователя пары чисел для суммирования

string rsp; // используется в условии, поэтому не может быть

            // определена в цикле do

do {

 cout << "please enter two values: ";

 int val1 = 0, val2 = 0;

 cin >> val1 >> val2;

 cout << "The sum of " << val1 << " and " << val2

      << " = " << val1 + val2 << "\n\n"

      << "More? Enter yes or no: ";

 cin >> rsp;

} while (!rsp.empty() && rsp[0] != 'n');

Цикл начинается запросом у пользователя двух чисел. Затем выводится их сумма и следует запрос, желает ли пользователь суммировать далее. Ответ пользователя проверяется в условии. Если ввод пуст или начинается с n, цикл завершается. В противном случае цикл повторяется.

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

do {

 // ...

 mumble(fоо) ;

} while (int foo = get_foo()); // ошибка: объявление в условии do

Если определить переменные в условии, то любое их использование произойдет прежде определения!

Упражнения раздела 5.4.4

Упражнение 5.18. Объясните каждый из следующих циклов. Исправьте все обнаруженные ошибки.

(a) do

     int v1, v2;

     cout << "Please enter two numbers to sum:";

     if (cin >> v1 >> v2)

      cout << "Sum is: " << v1 + v2 << endl;

    while (cin);

(b) do {

     // ...

    } while (int ival = get_response());

(c) do {

     int ival = get_response();

    } while (ival);

Упражнение 5.19. Напишите программу, использующую цикл do while для циклического запроса у пользователя двух строк и указания, которая из них меньше другой.

 

Операторы перехода прерывают поток выполнения. Язык С++ предоставляет четыре оператора перехода: break, continue и goto, рассматриваемые в этой главе, и оператор return, который будет описан в разделе 6.3.

 

5.5.1. Оператор

break

Оператор break завершает ближайший окружающий оператор while, do while, for или switch. Выполнение возобновляется с оператора, следующего непосредственно за завершаемым оператором.

Оператор break может располагаться только в цикле или операторе switch (включая операторы или блоки, вложенные в эти циклы). Оператор break воздействует лишь на ближайший окружающий цикл или оператор switch.

string buf;

while (cin >> buf && !buf.empty()) {

 switch(buf[0]) {

 case '-':

  // продолжать до первого пробела

  for (auto it = buf.begin() + 1; it != buf.end(); ++it) {

   if (*it == ' ')

    break; // #1, выйти из цикла for

   // ...

  }

  // break #1 передает управление сюда

  // дальнейшая обработка случая '-'

  break; // #2, выйти из оператора switch

 case '+':

  // ...

 } // конец оператора switch

 // break #2 передает управление сюда

} // конец оператора while

Оператор break с меткой #1 завершает цикл for в разделе case для случая дефиса. Он не завершает внешний оператор switch и даже не завершает обработку текущего случая. Выполнение продолжается с первого оператора после цикла for, который мог бы содержать дополнительный код обработки случая дефиса или оператор break, который завершает данный раздел.

Оператор break с меткой #2 завершает оператор switch, но не внешний цикл while. Выполнение кода после оператора break продолжает условие цикла while.

Упражнения раздела 5.5.1

Упражнение 5.20. Напишите программу, которая читает последовательность строк со стандартного устройства ввода до тех пор, пока не встретится повторяющееся слово или пока ввод слов не будет закончен. Для чтения текста по одному слову используйте цикл while. Для выхода из цикла при встрече двух совпадающих слов подряд используйте оператор break. Выведите повторяющееся слово, если оно есть, а в противном случае отобразите сообщение, свидетельствующее о том, что повторяющихся слов нет.

 

5.5.2. Оператор

continue

Операторcontinue прерывает текущую итерацию ближайшего цикла и немедленно начинает следующую. Оператор continue может присутствовать только в циклах for, while или do while, включая операторы или блоки, вложенные в такие циклы. Подобно оператору break, оператор continue во вложенном цикле воздействует только на ближайший окружающий цикл. Однако, в отличие от оператора break, оператор continue может присутствовать в операторе switch, только если он встроен в итерационный оператор.

Оператор continue прерывает только текущую итерацию; выполнение остается в цикле. В случае цикла while или do while выполнение продолжается с оценки условия. В традиционном цикле for выполнение продолжается в выражении заголовка. В серийном операторе for выполнение продолжается с инициализации управляющей переменной следующим элементом последовательности.

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

string buf;

while (cin >> buf && !buf.empty()) {

 if (buf[0] != '_')

  continue; // получить другой ввод

 // все еще здесь? ввод начинается с '_', обработка buf...

}

Упражнения раздела 5.5.2

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

 

5.5.3. Оператор

goto

Операторgoto обеспечивает безусловный переход к другому оператору в той же функции.

Не нужно использовать операторы goto. Они затрудняют и понимание, и изменение программ.

Оператор goto имеет следующий синтаксис:

goto метка ;

Метка (label) — это идентификатор, которым помечен оператор. Помеченный оператор (labeled statement) — это любой оператор, которому предшествует идентификатор, сопровождаемый двоеточием.

end: return; // помеченный оператор; может быть целью оператора goto

Метки независимы от имен, используемых для переменных и других идентификаторов. Следовательно, у метки может быть тот же идентификатор, что и у другой сущности в программе, не вступая в конфликт с другим одноименным идентификатором. Оператор goto и помеченный оператор, на который он передает управление, должны находиться в той же функции.

Подобно оператору switch, оператор goto не может передать управление из точки, где инициализированная переменная вышла из области видимости, в точку, где эта переменная находится в области видимости.

// ...

goto end;

int ix = 10; // ошибка: goto обходит определение инициализированной

             // переменной

end:

// ошибка: код здесь мог бы использовать ix,

//  но goto обошел ее объявление

ix = 42;

Переход назад за уже выполненное определение вполне допустим. Переходя назад к точке перед определением переменная приведет к ее удалению и повторному созданию.

// переход назад через определение

//  инициализированной переменной приемлем

begin:

int sz = get_size();

if (sz <= 0) {

 goto begin;

}

При выполнении оператора goto переменная sz удаляется, а затем она определяется и инициализируется снова, когда управление передается назад за ее определение после перехода к метке begin.

Упражнения раздела 5.5.3

Упражнение 5.22. Последний пример этого раздела, с переходом назад к метке begin, может быть написан лучше с использованием цикла. Перепишите код так, чтобы устранить оператор goto.

 

Исключения (exception) — это аномалии времени выполнения, такие как потеря подключения к базе данных или ввод непредвиденных данных, которые нарушают нормальное функционирование программы. Реакция на аномальное поведение может быть одним из самых трудных этапов разработки любой системы.

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

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

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

• Оператор throw используется частью кода обнаружившего проблему, с которой он не может справиться. Об операторе throw говорят, что он передает (raise) исключение.

• Блок try используется частью обработки исключения. Блок try начинается с ключевого слова try и завершается одной или несколькими директивами catch (catch clause). Исключения, переданные из кода, расположенного в блоке try, как правило, обрабатываются в одном из разделов catch. Поскольку разделы catch обрабатывают исключение, их называют также обработчиками исключений (exception handler).

• Набор определенных в библиотеке классов исключений (exception class) используется для передачи информации о произошедшем между операторами throw и соответствующими разделами catch.

В остальной части этого раздела три компонента обработки исключений рассматриваются последовательно. Более подробная информация об исключениях приведена в разделе 18.1.

 

5.6.1. Оператор

throw

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

Для примера вернемся к программе раздела 1.5.2, в которой суммируются два объекта класса Sales_item. Она проверяет, относятся ли обе прочитанные записи к одной книге. Если нет, она отображает сообщение об ошибке и завершает работу.

Sales_item item1, item2;

cin >> item1 >> item2;

// сначала проверить, представляют ли объекты item1 и item2

// одну и ту же книгу

if (item1.isbn() == item2.isbn()) {

 cout << item1 + item2 << endl;

 return 0; // свидетельство успеха

} else {

 cerr << "Data must refer to same ISBN"

      << endl;

 return -1; // свидетельство отказа

}

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

// сначала проверить, представляют ли объекты item1 и item2

// одну и ту же книгу

if (item1.isbn() != item2.isbn())

 throw runtime_error("Data must refer to same ISBN");

// если управление здесь, значит, ISBN совпадают

cout << item1 + item2 << endl;

Если теперь ISBN окажутся разными, будет передан объект исключения типа runtime_error. Передача исключения завершает работу текущей функции и передает управление обработчику, способному справиться с этой ошибкой.

Тип runtime_error является одним из типов исключения, определенных в заголовке stdexcept стандартной библиотеки. Более подробная информация по этой теме приведена в разделе 5.6.3. Объект класса runtime_error следует инициализировать объектом класса string или символьной строкой в стиле С (см. раздел 3.5.4). Эта строка представляет дополнительную информацию о проблеме.

 

5.6.2. Блок

try

Блок try имеет следующий синтаксис:

try {

 операторы_программы

} catch ( объявление_исключения ) {

  операторы_обработчика

} catch ( объявление_исключения ) {

 операторы_обработчика

} // ...

Блок try начинается с ключевого слова try, за которым следует блок кода, заключенный в фигурные скобки.

Блок try сопровождается одним или несколькими блоками catch. Блок catch состоит из трех частей: ключевого слова catch, объявления (возможно, безымянного) объекта в круглых скобках (называется объявлением исключения (exception declaration)) и операторного блока. Когда объявление исключения в блоке catch совпадает с исключением, выполняется связанный с ним блок. По завершении выполнения кода обработчика управление переходит к оператору, следующему непосредственно после него.

Операторы_программы в блоке try являются обычными программными операторами, реализующими ее логику. Подобно любым другим блокам кода, блоки try способны содержать любые операторы языка С++, включая объявления. Объявленные в блоке try переменные недоступны вне блока, в частности, они не доступны в блоках catch.

Создание обработчика

В приведенном выше примере, чтобы избежать суммирования двух объектов класса Sales_item, представляющих разные книги, использовался оператор throw. Предположим, что суммирующая объекты класса Sales_item часть программы отделена от части, взаимодействующей с пользователем. Эта часть могла бы содержать примерно такой код обработки исключения, переданного в блоке сложения.

while (cin >> item1 >> item2) {

 try {

  // код, который складывает два объекта класса Sales_item

  // если при сложении произойдет сбой, код передаст

  // исключение runtime_error

 } catch (runtime_error err) {

  // напомнить пользователю, что ISBN слагаемых объектов

  // должны совпадать

  cout << err.what()

       << "\nTry Again? Enter y or n" << endl;

  char c;

  cin >> с;

  if (!cin || с == 'n')

   break; // выход из цикла while

 }

}

В блоке try расположена обычная логика программы. Это сделано потому, что данная часть программы способна передать исключение типа runtime_error.

Данный блок try обладает одним разделом catch, который обрабатывает исключение типа runtime_error. Операторы в блоке после ключевого слова catch определяют действия, выполняемые в случае, если код в блоке try передаст исключение runtime_error. В данном случае обработка подразумевает отображение сообщения об ошибке и запрос у пользователя разрешения на продолжение. Когда пользователь вводит символ 'n', цикл while завершается, в противном случае он продолжается и считывает два новых объекта класса Sales_item.

В сообщении об ошибке используется текст, возвращенный функцией err.what(). Поскольку известно, что классом объекта исключения err является runtime_error, нетрудно догадаться, что функция what() является членом (см. раздел 1.5.2) класса runtime_error. В каждом из библиотечных классов исключений определена функция-член what(), которая не получает никаких аргументов и возвращает символьную строку в стиле С (т.е. const char*). В случае класса runtime_error эта строка является копией строки, использованной при инициализации объекта класса runtime_error. Если описанный в предыдущем разделе код передаст исключение, то отображенное разделом catch сообщение об ошибке будет иметь следующий вид:

Data must refer to same ISBN

Try Again? Enter y or n

При поиске обработчика выполнение функций прерывается

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

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

Если соответствующий раздел catch так и не будет найден, управление перейдет к библиотечной функции terminate(), которая определена в заголовке exception. Поведение этой функции зависит от системы, но обычно она завершает выполнение программы.

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

Внимание! Написание устойчивого к исключениям кода — довольно сложная задача

Важно понимать, что исключения прерывают нормальный поток программы. В месте, где происходит исключение, некоторые из действий, ожидаемых вызывающей стороной, могут быть выполнены, а другие нет. Как правило, пропуск части программы может означать, что объект останется в недопустимом или неполном состоянии, либо что ресурс не будет освобожден и т.д. Программы, которые правильно "зачищают" объекты во время обработки исключений, называют устойчивыми к исключениям (exception safe). Написание устойчивого к исключениям кода чрезвычайно сложно и практически не рассматривается в данном вводном курсе.

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

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

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

 

5.6.3. Стандартные исключения

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

• В заголовке exception определен общий класс исключения exception. Он сообщает только о том, что исключение произошло, но не предоставляет никакой дополнительной информации.

• В заголовке stdexcept определено несколько универсальных классов исключения (табл. 5.1).

• В заголовке new определен класс исключения bad_alloc, рассматриваемый в разделе 12.1.2.

• В заголовке type_info определен класс исключения bad_cast, рассматриваемый в разделе 19.2.

В классах exception, bad_alloc и bad_cast определен только стандартный конструктор (см. раздел 2.2.1), поэтому невозможно инициализировать объект этих типов.

Поведение исключений других типов прямо противоположно: их можно инициализировать объектом класса string или строкой в стиле С, однако значением по умолчанию их инициализировать нельзя. При создании объекта исключения любого из этих типов необходимо предоставить инициализатор. Этот инициализатор используется для предоставления дополнительной информации о произошедшей ошибке.

Таблица 5.1. Стандартные классы исключений, определенные в заголовке stdexcept

В классах исключений определена только одна функция what(). Она не получает никаких аргументов и возвращает константный указатель на тип char. Это указатель на символьную строку в стиле С (см. раздел 3.5.4), содержащую текст описания переданного исключения.

Содержимое символьного массива (строки в стиле С), указатель на который возвращает функция what(), зависит от типа объекта исключения. Для типов, которым при инициализации передают строку класса string, функция what() возвращает строку. Что же касается других типов, то возвращаемое значение зависит от компилятора.

Упражнения раздела 5.6.3

Упражнение 5.23. Напишите программу, которая читает два целых числа со стандартного устройства ввода и выводит результат деления первого числа на второе.

Упражнение 5.24. Перепишите предыдущую программу так, чтобы она передавала исключение, если второе число — нуль. Проверьте свою программу с нулевым вводом, чтобы увидеть происходящее при отсутствии обработчика исключения.

Упражнение 5.25. Перепишите предыдущую программу так, чтобы использовать для обработки исключения блок try. Раздел catch должен отобразить сообщение и попросить пользователя ввести новое число и повторить код в блоке try.

 

Определение функции (function definition) обычно состоит из типа возвращаемого значения (return type), имени, списка параметров (parameter) и тела функции. Параметры определяются в разделяемом запятыми списке, заключенном в круглые скобки. Выполняемые функцией действия определяются в блоке операторов (см. раздел 5.1), называемом телом функции (function body).

Для запуска кода функции используется оператор вызова (call operator), представляющий собой пару круглых скобок. Оператор вызова получает выражение, являющееся функцией или указателем на функцию. В круглых скобках располагается разделяемый запятыми список аргументов (argument). Аргументы используются для инициализации параметров функции. Тип вызываемого выражения — это тип возвращаемого значения функции.

Создание функции

В качестве примера напишем функцию вычисления факториала заданного числа. Факториал числа n является произведением чисел от 1 до n . Факториал 5, например, равен 120:

1 * 2 * 3 * 4 * 5 = 120

Эту функцию можно определить следующим образом:

// факториал val равен

// val * (val - 1) * (val - 2) ... * ((val - (val - 1)) * 1)

int fact(int val) {

 int ret = 1; // локальная переменная для содержания результата по

              // мере его вычисления

 while (val > 1)

  ret *= val--; // присвоение ret произведения ret * val

                // и декремент val

 return ret;    // возвратить результат

}

Функции присвоено имя fact. Она получает один параметр типа int и возвращает значение типа int. В цикле while вычисляется факториал с использованием постфиксного оператора декремента (см. раздел 4.5), уменьшающего значение переменной val на 1 при каждой итерации. Оператор return выполняется в конце функции fact и возвращает значение переменной ret.

Вызов функции

Чтобы вызвать функцию fact(), следует предоставить ей значение типа int. Результатом вызова также будет значение типа int:

int main() {

 int j = fact(5); // j равно 120, т.е. результату fact(5)

 cout << "5! is " << j << endl;

 return 0;

}

Вызов функции осуществляет два действия: он инициализирует параметры функции соответствующими аргументами и передает управление коду этой функции. При этом выполнение вызывающей (calling) функции приостанавливается и начинается выполнение вызываемой (called) функции.

Выполнение функции начинается с неявного определения и инициализации ее параметров. Таким образом, когда происходит вызов функции fact(), сначала создается переменная типа int по имени val. Эта переменная инициализируется аргументом, предоставленным при вызове функции fact(), которым в данном случае является 5.

Выполнение функции заканчивается оператором return. Как и вызов функции, оператор return осуществляет два действия: возвращает значение (если оно есть) и передает управление назад вызывающей функции. Возвращенное функцией значение используется для инициализации результата вызывающего выражения. Выполнение продолжается с остальной частью выражения, в составе которого осуществлялся вызов. Таким образом, вызов функции fact() эквивалентен следующему:

int val = 5; // инициализировать val из литерала 5

int ret = 1; // код из тела функции fact

while (val > 1)

 ret *= val--;

int j = ret; // инициализировать j копией ret

Параметры и аргументы

Аргументы — это инициализаторы для параметров функции. Первый аргумент инициализирует первый параметр, второй аргумент инициализирует второй параметр и т.д. Хотя порядок инициализации параметров аргументами известен, порядок обработки аргументов не гарантирован (см. раздел 4.1.3). Компилятор может вычислять аргументы в любом порядке по своему предпочтению.

Тип каждого аргумента должен совпадать с типом соответствующего параметра, как и тип любого инициализатора должен совпадать с типом объекта, который он инициализирует. Следует передать точно такое же количество аргументов, сколько у функции параметров. Поскольку каждый вызов гарантированно передаст столько аргументов, сколько у функции параметров, последние всегда будут инициализированы.

Поскольку у функции fact() один параметр типа int, при каждом ее вызове следует предоставить один аргумент, который может быть преобразован в тип int (см. раздел 4.11):

fact("hello");   // ошибка: неправильный тип аргумента

fact();          // ошибка: слишком мало аргументов

fact(42, 10, 0); // ошибка: слишком много аргументов

fact(3.14);      // ok: аргумент преобразуется в int

Первый вызов терпит неудачу потому, что невозможно преобразование значения типа const char* в значение типа int. Второй и третий вызовы передают неправильные количества аргументов. Функцию fact() следует вызывать с одним аргументом; ее вызов с любым другим количеством аргументов будет ошибкой. Последний вызов допустим, поскольку значение типа double преобразуется в значение типа int. В этом случае аргумент неявно преобразуется в тип int (с усечением). После преобразования этот вызов эквивалентен следующему:

fact(3);

Список параметров функции

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

void f1() { /* ... */ } // неявно указанный пустой список параметров

void f2(void) { /* ... */ } // явно указанный пустой список параметров

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

int f3(int v1, v2) { /* ... */ }    // ошибка

int f4(int v1, int v2) { /* ... */} // ok

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

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

Тип возвращаемого значения функции

В качестве типа возвращаемого значения функции применимо большинство типов. В частности, типом возвращаемого значения может быть void, это означает, что функция не возвращает значения. Но типом возвращаемого значения не может быть массив (см. раздел 3.5) или функция. Однако функция может возвратить указатель на массив или функцию. Определение функции, возвращающей указатель (или ссылку) на массив, рассматривается в разделе 6.3.3, а указателя на функцию — в разделе 6.7.

Упражнения раздела 6.1

Упражнение 6.1. В чем разница между параметром и аргументом?

Упражнение 6.2. Укажите, какие из следующих функций ошибочны и почему. Предложите способ их исправления.

(a) int f() {

     string s;

     // ...

     return s;

    }

(b) f2(int i) { /* ... */ }

(c) int calc(int v1, int v1) /* ... */ }

(d) double square(double x) return x * x;

Упражнение 6.3. Напишите и проверьте собственную версию функции fact().

Упражнение 6.4. Напишите взаимодействующую с пользователем функцию, которая запрашивает число и вычисляет его факториал. Вызовите эту функцию из функции main().

Упражнение 6.5. Напишите функцию, возвращающую абсолютное значение ее аргумента.

 

6.1.1. Локальные объекты

В языке С++ имя имеет область видимости (см. раздел 2.2.4), а объекты — продолжительность существования (object lifetime). Обе эти концепции важно понимать.

• Область видимости имени — это часть текста программы, в которой имя видимо.

• Продолжительность существования объекта — это время при выполнении программы, когда объект существует.

Как уже упоминалось, тело функции — это блок операторов. Как обычно, блок формирует новую область видимости, в которой можно определять переменные. Параметры и переменные, определенные в теле функции, называются локальными переменными (local variable). Они являются локальными для данной функции и скрывают (hide) объявления того же имени во внешней области видимости.

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

Автоматические объекты

Объекты, соответствующие обычным локальным переменным, создаются при достижении процессом выполнения определения переменной в функции. Они удаляются, когда процесс выполнения достигает конца блока, в котором определена переменная. Объекты, существующие только во время выполнения блока, известны как автоматические объекты (automatic object). После выхода процесса выполнения из блока значения автоматических объектов, созданных в этом блоке, неопределенны.

Параметры — это автоматические объекты. Место для параметров резервируется при запуске функции. Параметры определяются в пределах тела функции. Следовательно, они удаляются по завершении функции.

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

Локальные статические объекты

Иногда полезно иметь локальную переменную, продолжительность существования которой не прерывается между вызовами функции. Чтобы получить такие объекты, при определении локальной переменной используют ключевое слово static. Каждый локальный статический объект (local static object) инициализируется прежде, чем выполнение достигнет определения объекта. Локальная статическая переменная не удаляется по завершении функции; она удаляется по завершении программы.

В качестве простого примера рассмотрим функцию, подсчитывающую количество своих вызовов:

size_t count_calls() {

 static size_t ctr = 0; // значение сохраняется между вызовами

 return ++ctr;

}

int main() {

 for (size_t i = 0; i != 10; ++i)

  cout << count_calls() << endl;

 return 0;

}

Эта программа выводит числа от 1 до 10 включительно.

Прежде чем процесс выполнения впервые достигнет определения переменной ctr, она уже будет создана и получит исходное значение 0. Каждый вызов осуществляет инкремент переменной ctr и возвращает ее новое значение. При каждом запуске функции count_calls() переменная ctr уже существует и имеет некое значение, возможно, оставленное последним вызовом функции. Поэтому при втором вызове значением переменной ctr будет 1, при третьем — 2 и т.д.

Если у локальной статической переменной нет явного инициализатора, она инициализируется значением по умолчанию (см. раздел 3.3.1), следовательно, локальные статические переменные встроенного типа инициализируются нулем.

Упражнения раздела 6.1.1

Упражнение 6.6. Объясните различия между параметром, локальной переменной и локальной статической переменной. Приведите пример функции, в которой каждая из них могла бы быть полезной.

Упражнение 6.7. Напишите функцию, которая возвращает значение 0 при первом вызове, а при каждом последующем вызове возвращает последовательно увеличивающиеся числа.

 

6.1.2. Объявление функций

Как и любое другое имя, имя функции должно быть объявлено прежде, чем его можно будет использовать. Подобно переменным (см. раздел 2.2.2), функция может быть определена только однажды, но объявлена может быть многократно. За одним исключением, которое будет описано в разделе 15.3, можно объявить функцию, которая не определяется до тех пор, пока она не будет использована.

Объявление функции подобно ее определению, но у объявления нет тела функции. В объявлении тело функции заменяет точка с запятой.

Поскольку у объявления функции нет тела, нет никакой необходимости в именах параметров. Поэтому имена параметров зачастую отсутствуют в объявлении. Хоть имена параметров и не обязательны, они зачастую используются, чтобы помочь пользователям функции понять ее назначение:

// имена параметров указывают, что итераторы обозначают диапазон

// выводимых значений

void print(vector::const_iterator beg,

           vector::const_iterator end);

Эти три элемента объявления (тип возвращаемого значения, имя функции и тип параметров) описывают интерфейс (interface) функции. Они задают всю информацию, необходимую для вызова функции. Объявление функции называют также прототипом функции (function prototype).

Объявления функций находятся в файлах заголовка

Напомним, что объявления переменных располагают в файлах заголовка (см. раздел 2.6.3), а определения — в файлах исходного кода. По тем же причинам функции должны быть объявлены в файлах заголовка и определены в файлах исходного кода.

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

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

Упражнения раздела 6.1.2

Упражнение 6.8. Напишите файл заголовка по имени Chapter6.h, содержащий объявления функций, написанных для упражнений раздела 6.1

 

6.1.3. Раздельная компиляция

По мере усложнения программ возникает необходимость хранить различные части программы в отдельных файлах. Например, функции, написанные для упражнений раздела 6.1, можно было бы сохранить в одном файле, а код, использующий их, в других файлах исходного кода. Язык С++ позволяет разделять программы на логические части, предоставляя средство, известное как раздельная компиляция (separate compilation). Раздельная компиляция позволяет разделять программы на несколько файлов, каждый из которых может быть откомпилирован независимо.

Компиляция и компоновка нескольких файлов исходного кода

Предположим, например, что определение функции fact() находится в файле fact.cc, а ее объявление — в файле заголовка Chapter6.h. Файл fact.cc, как и любой другой файл, использующий эту функцию, будет включать заголовок Chapter6.h. Функцию main(), вызывающую функцию fact(), будем хранить в еще одном файле factMain.cc.

Чтобы создать исполнимый файл (executable file), следует указать компилятору, где искать весь используемый код. Эти файлы можно было бы откомпилировать следующим образом:

$ CC factMain.cc fact.cc # generates factMain.exe or a.out

$ CC factMain.cc fact.cc -o main # generates main or main.exe

где CC — имя компилятора; $ — системная подсказка; # — начало комментария командной строки. Теперь можно запустить исполняемый файл, который выполнит нашу функцию main().

Если бы изменен был только один из наших файлов исходного кода, то перекомпилировать достаточно было бы только тот файл, который был фактически изменен. Большинство компиляторов предоставляет возможность раздельной компиляции каждого файла. Обычно этот процесс создает файл с расширением .obj (на Windows) или .o (на UNIX), указывающим, что этот файл содержит объектный код (object code).

Компилятор позволяет скомпоновать (link) объектные файлы (object file) и получить исполняемый файл. На системе авторов раздельная компиляция программы осуществляется следующим образом:

$ CC -с factMain.cc            # generates factMain.o

$ CC -c fact.cc                # generates fact.o

$ CC factMain.o fact.o         # generates factMain.exe or a.out

$ CC factMain.o fact.o -o main # generates main or main.exe

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

Упражнения раздела 6.1.3

Упражнение 6.9. Напишите собственные версии файлов fact.cc и factMain.cc. Эти файлы должны включать заголовок Chapter6.h из упражнения предыдущего раздела. Используйте эти файлы чтобы понять, как ваш компилятор обеспечивает раздельную компиляцию.

 

Как уже упоминалось, при каждом вызове функции ее параметры создаются заново. Используемое для инициализации параметра значение предоставляет соответствующий аргумент, переданный при вызове.

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

Как и у любой другой переменной, взаимодействие параметра и его аргумента определяет тип параметра. Если параметр — ссылка (см. раздел 2.3.1), то параметр привязывается к своему аргументу. В противном случае, значение аргумента копируется.

Когда параметр — ссылка, говорят, что его аргумент передается по ссылке (pass by reference) или что функция вызывается по ссылке (call by reference). Подобно любой другой ссылке, ссылочный параметр — это только псевдоним объекта, к которому он привязан, т.е. ссылочный параметр — псевдоним своего аргумента.

Когда значение аргумента копируется, параметр и аргумент — независимые объекты. Говорят, что такие аргументы передаются по значению (pass by value) или что функция вызывается по значению (call by value).

 

6.2.1. Передача аргумента по значению

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

int n = 0; // обычная переменная типа int

int i = n; // i - копия значения переменной n

i = 42;    // значение i изменилось, значение n - нет

Передача аргумента по значению осуществляется точно так же; что бы функция не сделала с параметром, на аргумент это не повлияет. Например, в функции fact() (см. раздел 6.1) происходит декремент параметра val:

ret *= val--; // декремент значения val

Хотя функция fact() изменила значение val, это изменение никак не повлияло на переданный ей аргумент. Вызов fact(i) не изменяет значение переменной i.

Параметры указателя

Указатели (см. раздел 2.3.2) ведут себя, как любой не ссылочный тип. При копировании указателя его значение копируется. После создания копии получается два отдельных указателя. Однако указатель обеспечивает косвенный доступ к объекту, на который он указывает. Значение этого объекта можно изменить при помощи указателя (см. раздел 2.3.2):

int n = 0, i = 42;

int *p = &n, *q = &i; // p указывает на n; q указывает на i

*p = 42;              // значение n изменилось, значение p - нет

p = q;                // теперь p указывает на i; значения i и n

                      // неизменны

То же поведение характерно для указателей, являющихся параметрами:

// функция получает указатель и обнуляет значение, на которое он

// указывает

void reset(int *ip) {

 *ip = 0; // изменяет значение объекта, на который указывает ip

 ip = 0;  // изменяет только локальную копию ip; аргумент неизменен

}

После вызова функции reset() объект, на который указывает аргумент, будет обнулен, но сам аргумент-указатель не изменится:

int i = 42;

reset(&i);                   // изменяет значение i, но не адрес

cout << "i = " << i << endl; // выводит i = 0

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

Упражнения раздела 6.2.1

Упражнение 6.10. Напишите, используя указатели, функцию, меняющую значения двух целых чисел. Проверьте функцию, вызвав ее и отобразив измененные значения.

 

6.2.2. Передача аргумента по ссылке

Напомним, что операции со ссылками — это фактически операции с объектами, к которым они привязаны (см. раздел 2.3.1):

int n = 0, i = 42;

int &r = n; // r привязан к n (т.е. r - другое имя для n)

r = 42;     // теперь n = 42

r = i;      // теперь n имеет то же значение, что и i

i = r;      // i имеет то же значение, что и n

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

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

// функция, получающая ссылку на объект типа int и обнуляющая его

void reset(int &i) // i - только другое имя объекта, переданного

                   // на обнуление

{

 i = 0; // изменяет значение объекта, на который ссылается i

}

Подобно любой другой ссылке, ссылочный параметр связывается непосредственно с объектом, которым он инициализируется. При вызове этой версии функции reset() параметр i будет связан с любым переданным ей объектом типа int. Как и с любой ссылкой, изменения, сделанные с параметром i, осуществляются с объектом, на который она ссылается. В данном случае этот объект — аргумент функции reset().

Когда вызывается эта версия функции reset(), объект передается непосредственно; поэтому нет никакой необходимости в передаче его адреса:

int j = 42;

reset(j); // j передается по ссылке; значение в j изменяется

cout << "j = " << j << endl; // выводит j = 0

В этом вызове параметр i — это только другое имя переменной j. Любое использование параметра i в функции reset() фактически является использованием переменной j.

Использование ссылки во избежание копирования

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

В качестве примера напишем функцию сравнения длин двух строк. Поскольку строки могут быть очень длинными и их копирования желательно избежать, сделаем параметры ссылками. Так как сравнение двух строк не подразумевает их изменения, сделаем ссылочные параметры константами (см. раздел 2.4.1):

// сравнить длины двух строк

bool isShorter(const string &s1, const string &s2) {

 return s1.size() < s2.size();

}

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

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

Использование ссылочных параметров для возвращения дополнительной информации

Функция может возвратить только одно значение. Но что если функции нужно возвратить больше одного значения? Ссылочные параметры позволяют возвратить несколько результатов. В качестве примера определим функцию find_char(), которая возвращает позицию первого вхождения заданного символа в строке. Функция должна также возвращать количество этих символов в строке.

Как же определить функцию, возвращающую и позицию, и количество вхождений? Можно было бы определить новый тип, содержащий позицию и количество. Однако куда проще передать дополнительный ссылочный аргумент, содержащий количество вхождений:

// возвращает индекс первого вхождения с в s

// ссылочный параметр occurs содержит количество вхождений

string::size_type find_char(const string &s, char c,

                            string::size_type &occurs) {

 auto ret = s.size(); // позиция первого вхождения, если оно есть

 occurs = 0;          // установить параметр количества вхождений

 for (decltype(ret) i = 0; i != s.size(); ++i) {

  if (s[i] == c) {

   if (ret == s.size())

    ret = i; // запомнить первое вхождение с

   ++occurs; // инкремент счетчика вхождений

  }

 }

 return ret; // количество возвращается неявно в параметре occurs

}

Когда происходит вызов функции find_char(), ей передаются три аргумента: строка, в которой осуществляется поиск, искомый символ и объект типа size_type (раздел 3.2.2), содержащий счетчик вхождений. Если s является объектом класса string, a ctr — объектом типа size_type, то функцию find_char() можно вызвать следующим образом:

auto index = find_char(s, 'o', ctr);

После вызова значением объекта ctr будет количество вхождений символа о, a index укажет на его первое вхождение, если оно будет. В противном случае значение index будет равно s.size(), a ctr — нулю.

Упражнения раздела 6.2.2

Упражнение 6.11. Напишите и проверьте собственную версию функции reset(), получающую ссылку.

Упражнение 6.12. Перепишите программу из упражнения 6.10 раздела 6.2.1 так, чтобы использовать ссылки вместо указателей при смене значений двух целочисленных переменных. Какая из версий, по вашему, проще в использовании и почему?

Упражнение 6.13. Если Т — имя типа, объясните различие между функцией, объявленной как void f(Т) и как void f(Т&).

Упражнение 6.14. Приведите пример, когда параметр должен быть ссылочным типом. Приведите пример случая, когда параметр не должен быть ссылкой.

Упражнение 6.15. Объясните смысл каждого из типов параметров функции find_char(). В частности, почему s — ссылка на константу, a occurs — простая ссылка? Почему эти параметры ссылочные, а параметр с типа char нет? Что будет, сделай мы s простой ссылкой? Что если occurs сделать константной ссылкой?

 

6.2.3. Константные параметры и аргументы

При использовании параметров, являющихся константой, следует помнить об обсуждении спецификатора const верхнего уровня из раздела 2.4.3. Как упоминалось в этом разделе, спецификатор const верхнего уровня — это тот спецификатор, который относится непосредственно к объекту:

const int ci = 42;  // нельзя изменить ci; const верхнего уровня

int i = ci;         // ok: при копировании ci спецификатор const

                    //  верхнего уровня игнорируется

int * const p = &i; // const верхнего уровня; нельзя присвоить p

*p = 0;             // ok: изменение при помощи p возможно; i теперь 0

Как и при любой другой инициализации, при копировании аргумента для инициализации параметра спецификаторы const верхнего уровня игнорируются. В результате спецификатор const верхнего уровня для параметров игнорируется. Параметру, у которого есть спецификатор const верхнего уровня, можно передать и константный, и неконстантный объект:

void fcn(const int i) { /* fcn может читать, но не писать в i */ }

Функцию fcn() можно вызвать, передав ей аргумент типа const int или обычного типа int. Тот факт, что спецификаторы const верхнего уровня игнорируются у параметра, может иметь удивительные последствия:

void fcn(const int i) { /* fcn может читать, но не писать в i */ }

void fcn(int i) { /* ... */ } // ошибка: переопределяет fcn(int)

В языке С++ можно определить несколько разных функций с одинаковым именем. Однако это возможно только при достаточно большом различии их списков параметров. Поскольку спецификаторы const верхнего уровня игнорируются, мы можем передать те же типы любой версии функции fcn(). Вторая версия функции fcn() является ошибкой. Несмотря на внешний вид, ее список параметров не отличается от списка первой версии функции fcn().

Параметры в виде указателей или ссылок и константность

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

int i = 42;

const int *cp = &i; // ok: но cp не может изменить i (раздел 2.4.2)

const int &r = i;   // ok: но r не может изменить i (раздел 2.4.1)

const int &r2 = 42; // ok: (раздел 2.4.1)

int *p = cp;  // ошибка: типы p и cp не совпадают (раздел 2.4.2)

int &r3 = r;  // ошибка: типы r3 и r не совпадают (раздел 2.4.1)

int &r4 = 42; // ошибка: нельзя инициализировать простую ссылку из

              //         литерала (раздел 2.3.1)

Те же правила инициализации относятся и к передаче параметров:

int i = 0;

const int ci = i;

string::size_type ctr = 0;

reset(&i);  // вызывает версию функции reset с параметром типа int*

reset(&ci); // ошибка: нельзя инициализировать int* из указателя на

            //         объект const int

reset(i);   // вызывает версию функции reset с параметром типа int&

reset(ci);  // ошибка: нельзя привязать простую ссылку к константному

            //         объекту ci

reset(42);  // ошибка: нельзя привязать простую ссылку к литералу

reset(ctr); // ошибка: типы не совпадают; ctr имеет беззнаковый тип

// ok: первый параметр find_char является ссылкой на константу

find_char("Hello World!", 'o', ctr);

Ссылочную версию функции reset() (см. раздел 6.2.2) можно вызвать только для объектов типа int. Нельзя передать литерал, выражение, результат которого будет иметь тип int, объект, который требует преобразования, или объект типа const int. Точно так же версии функции reset() с указателем можно передать только объект типа int* (см. раздел 6.2.1). С другой стороны, можно передать строковый литерал как первый аргумент функции find_char() (см. раздел 6.2.2). Ссылочный параметр этой функции — ссылка на константу, и можно инициализировать ссылки на константу из литералов.

#magnify.png По возможности используйте ссылки на константы

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

В качестве примера рассмотрим функцию find_char() из раздела 6.2.2. Строковый параметр этой функции правильно сделан ссылкой на константу. Если бы этот параметр был определен как string&:

// ошибка: первый параметр должен быть const string&

string::size_type find_char(string &s, char c,

                            string::size_type &occurs);

то вызвать ее можно было бы только для объекта класса string, так что

find_char("Hello World", 'o', ctr);

привело бы к неудаче во времени компиляции.

Более того, эту версию функции find_char() нельзя использовать из других функций, которые правильно определяют свои параметры как ссылки на константу. Например, мы могли бы использовать функцию find_char() в функции, которая определяет, является ли строка предложением:

bool is_sentence(const string &s) {

 // если в конце s есть точка, то строка s - предложение

 string::size_type ctr = 0;

 return find_char(s, ctr) == s.size() - 1 && ctr == 1;

}

Если бы функция find_char() получала простую ссылку string?, то этот ее вызов привел бы к ошибке при компиляции. Проблема в том, что s — ссылка на const string, но функция find_char() была неправильно определена как получающая простую ссылку.

Было бы заманчиво попытаться исправить эту проблему, изменив тип параметра в функции is_sentence(). Но это только распространит ошибку, так как вызывающая сторона функции is_sentence() сможет передавать только неконстантные строки.

Правильный способ решения этой проблемы — исправить параметр функции find_char(). Если невозможно изменить функцию find_char(), определите локальную копию строки s в функции is_sentence() и передавайте эту строку функции find_char().

Упражнения раздела 6.2.3

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

bool is_empty(string& s) { return s.empty(); }

Упражнение 6.17. Напишите функцию, определяющую, содержит ли строка какие-нибудь заглавные буквы. Напишите функцию, переводящую всю строку в нижний регистр. Использованные в этих функциях параметры имеют тот же тип? Если да, то почему? Если нет, то тоже почему?

Упражнение 6.18. Напишите объявления для каждой из следующих функций. Написав объявления, используйте имя функции для обозначения того, что она делает.

(a) Функция compare() возвращает значение типа bool и получает два параметра, являющиеся ссылками на класс matrix.

(b) Функция change_val() возвращает итератор vector и получает два параметра: один типа int, а второй итератор для вектора vector.

Упражнение 6.19. С учетом следующего объявления определите, какие вызовы допустимы, а какие нет. Объясните, почему они недопустимы.

double calc(double);

int count(const string &, char);

int sum(vector::iterator, vector::iterator, int);

vector vec(10);

(a) calc(23.4, 55.1); (b) count("abcda", 'a');

(c) calc(66);         (d) sum(vec.begin(), vec.end(), 3.8);

Упражнение 6.20. Когда ссылочные параметры должны быть ссылками на константу? Что будет, если сделать параметр простой ссылкой, когда это могла быть ссылка на константу?

 

6.2.4. Параметры в виде массива

Массивы обладают двумя особенностями, влияющими на определение и использование функций, работающих с массивами: массив нельзя скопировать (см. раздел 3.5.1), имя массива при использовании автоматически преобразуется в указатель на его первый элемент (см. раздел 3.5.3). Поскольку копировать массив нельзя, его нельзя передать функции по значению. Так как имя массива автоматически преобразуется в указатель, при передаче массива функции фактически передается указатель на его первый элемент.

Хотя передать массив по значению нельзя, вполне можно написать параметр, который выглядит как массив:

// несмотря на внешний вид,

//  эти три объявления функции print эквивалентны

// у каждой функции есть один параметр типа const int*

void print(const int*);

void print(const int[]);   // демонстрация намерения получить массив

void print(const int[10]); // размерность только для документирования

Независимо от внешнего вида, эти объявления эквивалентны: в каждом объявлена функция с одним параметром типа const int*. Когда компилятор проверяет вызов функции print(), он выясняет только то, что типом аргумента является const int*:

int i = 0, j[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
= {0, 1};

print(&i); // ok: &i - int*

print(j);  // ok: j преобразуется в int*, указывающий на j[0]

Если передать массив функции print(), то этот аргумент автоматически преобразуется в указатель на первый элемент в массиве; размер массива не имеет значения.

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

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

Использование маркера для определения продолжения массива

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

void print(const char *cp) {

 if (cp)      // если cp не нулевой указатель

  while (*cp) // пока указываемый символ не является нулевым

   cout << *cp++; // вывести символ и перевести указатель

}

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

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

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

void print(const int *beg, const int *end) {

 // вывести все элементы, начиная с beg и до, но не включая, end

 while (beg != end)

  cout << *beg++ << endl; // вывести текущий элемент

                          // и перевести указатель

}

Для вывода текущего элемента и перевода указателя beg на следующий элемент массива цикл while использует операторы обращения к значению и постфиксного инкремента (см. раздел 4.5). Цикл останавливается, когда beg становится равен end.

При вызове этой функции передаются два указателя: один на первый подлежащий отображению элемент и один на элемент после последнего:

int j[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
= {0, 1};

// j преобразуется в указатель на первый элемент массива j

// второй аргумент - указатель на следующий элемент после конца j

print(begin(j), end(j)); // функции begin и end см. p. 3.5.3

Эта функция безопасна, пока вызывающая сторона правильно вычисляет указатели. Здесь эти указатели предоставляют библиотечные функции begin() и end() (см. раздел 3.5.3).

Явная передача параметра размера

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

// const int ia[] - эквивалент const int* ia

// размер передается явно и используется для контроля доступа

// к элементам ia

void print(const int ia[], size_t size) {

 for (size_t i = 0; i != size; ++i) {

  cout << ia[i] << endl;

 }

}

Эта версия использует параметр size для определения количества выводимых элементов. Когда происходит вызов функции print(), ей следует передать этот дополнительный параметр:

int j[] = { 0, 1 }; // массив типа int размером 2

print(j, end(j) - begin(j));

Функция безопасна, пока переданный размер не превосходит реальную величину массива.

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

Обратите внимание, что все три версии функции print() определяли свои параметры массива как указатели на константу. В разделе 6.2.3 было упомянуто о схожести указателей и ссылок. Когда функция не нуждается в записи элементов массива, параметр массива должен быть указателем на константу (см. раздел 2.4.2). Параметр должен быть простым указателем на неконстантный тип, только если функция должна изменять значения элементов.

Ссылочный параметр массива

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

// ok: параметр является ссылкой на массив; размерность - часть типа

void print(int (&arr)[10]) {

 for (auto elem : arr)

  cout << elem << endl;

}

Круглые скобки вокруг части &arr необходимы (см. раздел 3.5.1):

f(int &arr[10])   // ошибка: объявляет arr как массив ссылок

f(int (&arr)[10]) // ok: arr - ссылка на массив из десяти целых чисел

Поскольку размер массива является частью его типа, на размерность в теле функции вполне можно положиться. Однако тот факт, что размер является частью типа, ограничивает полноценность этой версии функции print(). Эту функцию можно вызвать только для массива из десяти целых чисел:

int i = 0, j[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
= {0, 1};

int k[10] = {0,1,2,3,4,5,6,7,8,9};

print(&i); // ошибка: аргумент не массив из десяти целых чисел

print(j);  // ошибка: аргумент не массив из десяти целых чисел

print(k);  // ok: аргумент массив из десяти целых чисел

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

Передача многомерного массива

Напомним, что в языке С++ нет многомерных массивов (см. раздел 3.6). Вместо многомерных массивов есть массив массивов.

Подобно любому массиву, многомерный массив передается как указатель на его первый элемент (см. раздел 3.6). Поскольку речь идет о массиве массивов, элемент которого сам является массивом, указатель является указателем на массив. Размер второй размерности (и любой последующий) является частью типа элемента и должен быть определен:

// matrix указывает на первый элемент массива, элементы которого

// являются массивами из десяти целых чисел

void print(int (*matrix)[10], int rowSize) { /* ... */ }

Объявляет matrix указателем на массив из десяти целых чисел.

Круглые скобки вокруг *matrix снова необходимы:

int *matrix[10];   // массив из десяти указателей

int (*matrix)[10]; // указатель на массив из десяти целых чисел

Функцию можно также определить с использованием синтаксиса массива. Как обычно, компилятор игнорирует первую размерность, таким образом, лучше не включать ее:

// эквивалентное определение

void print (int matrix[][10], int rowSize) { /* ... */ }

Здесь объявление matrix выглядит как двумерный массив. Фактически параметр является указателем на массив из десяти целых чисел.

Упражнения раздела 6.2.4

Упражнение 6.21. Напишите функцию, получающую значение типа int и указатель на тип int, а возвращающую значение типа int, если оно больше, или значение, на которое указывает указатель, если больше оно. Какой тип следует использовать для указателя?

Упражнение 6.22. Напишите функцию, меняющую местами два указателя на тип int.

Упражнение 6.23. Напишите собственные версии каждой из функций print(), представленных в этом разделе. Вызовите каждую из этих функций для вывода i и j, определенных следующим образом:

int i = 0, j[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
= {0, 1};

Упражнение 6.24. Объясните поведение следующей функции. Если в коде есть проблемы, объясните, где они и как их исправить.

void print(const int ia[10]) {

 for (size_t i = 0; i != 10; ++i)

  cout << ia[i] << endl;

}

 

6.2.5. Функция

main()

: обработка параметров командной строки

Функция main() — хороший пример того, как программы на языке С++ передают массивы в функции. До сих пор функция main() в примерах определялась с пустым списком параметров.

int main() { ... }

Но зачастую функции main() необходимо передать аргументы. Обычно аргументы функции main() используют для того, чтобы позволить пользователю задать набор параметров, влияющих на работу программы. Предположим, например, что функция main() программы находится в исполняемом файле по имени prog. Параметры программе можно передавать следующим образом:

prog -d -о ofile data0

Так, параметры командной строки передаются функции main() в двух (необязательных) параметрах:

int main(int argc, char *argv[]) { ... }

Второй параметр, argv, является массивом указателей на символьные строки в стиле С, а первый параметр, argc, передает количество строк в этом массиве. Поскольку второй параметр является массивом, функцию main(), в качестве альтернативы, можно определить следующим образом:

int main(int argc, char **argv) { ... }

Обратите внимание: указатель argv указывает на тип char*. При передаче аргументов функции main() первый элемент массива argv содержит либо имя программы, либо является пустой строкой. Последующие элементы передают аргументы, предоставленные в командной строке. Элемент сразу за последним указателем гарантированно будет нулем.

С учетом предыдущей командной строки argc содержит значение 5, a argv — следующие символьные строки в стиле С:

argv[0] = "prog"; // может также указывать на пустую строку

argv[1]На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .
= "-d";

argv[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
= "-o";

argv[3]Согласно другой трактовке, исключение — это объект системного или пользовательского класса, создаваемого операционной системой или кодом программы в ответ на обстоятельства, либо не допускающие дальнейшего нормального выполнения программы, либо определенные пользователем. Обработка исключений в приложении позволяет корректно выйти из затруднительной ситуации. — Примеч. ред .
= "ofile";

argv[4]Здесь и везде в оригинале именно adapt o r, а не adapt e r. — Примеч. ред .
= "data0";

argv[5] = 0;

При использовании аргументов в массиве argv помните, что дополнительные аргументы начинаются с элемента argv[1]На самом деле препроцессору. Компилятор получит готовый промежуточный файл, в состав которого войдет содержимое подключенной библиотеки. — Примеч. ред .
; элемент argv[0] содержит имя программы, а не введенный пользователем параметр.

Упражнения раздела 6.2.5

Упражнение 6.25. Напишите функцию main(), получающую два аргумента. Конкатенируйте предоставленные аргументы и выведите полученную строку.

Упражнение 6.26. Напишите программу, которая способна получать параметры командной строки, описанные в этом разделе. Отобразите значения аргументов, переданных функции main().

 

6.2.6. Функции с переменным количеством параметров

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

Новый стандарт предоставляет два основных способа создания функций, получающих переменное количество аргументов: если у всех аргументов тот же тип, можно передать объект библиотечного класса initializer_list. Если типы аргументов разные, можно написать функцию специального вида, известную как шаблон с переменным количеством аргументов (variadic template), который мы рассмотрим в разделе 16.4.

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

Параметры типа initializer_list

Функцию, получающую произвольное количество аргументов одинакового типа, можно написать, используя параметр типа initializer_list. Тип initializer_list — это библиотечный класс, который представляет собой массив (см. раздел 3.5) значений определенного типа. Этот тип определен в заголовке initializer_list. Операции, предоставляемые классом initializer_list, перечислены в табл. 6.1.

Таблица 6.1. Операции, предоставляемые классом initializer_list

Подобно типу vector, тип initializer_list является шаблоном (см. раздел 3.3). При определении объекта класса initializer_list следует указать тип элементов, которые будет содержать список:

initializer_list ls; // initializer_list строк

initializer_list li;    // initializer_list целых чисел

В отличие от вектора, элементы списка initializer_list всегда константы; нет никакого способа изменить значение его элементов.

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

void error_msg(initializer_list il) {

 for (auto beg = il.begin(); beg != il.end(); ++beg)

  cout << *beg << " ";

 cout << endl;

}

Методы begin() и end() объектов класса initializer_list аналогичны таковым у класса vector (см. раздел 3.4.1). Метод begin() предоставляет указатель на первый элемент списка, а метод end() — на следующий элемент после последнего. Наша функция инициализирует переменную beg указателем на первый элемент и перебирает все элементы списка initializer_list. В теле цикла осуществляется обращение к значению beg, что позволяет получить доступ к текущему элементу и вывести его значение.

При передаче последовательности значений в параметре типа initializer_list последовательность следует заключить в фигурные скобки:

// expected и actual - строки

if (expected != actual)

 error_msg({"functionX", expected, actual});

else

 error_msg({"functionX", "okay"});

Здесь той же функции error_msg() передаются при первом вызове три значения, а при втором — два.

У функции с параметром initializer_list могут быть также и другие параметры. Например, у нашей системы отладки мог бы быть класс ErrCode, представляющий различные виды ошибок. Мы можем пересмотреть свою программу так, чтобы в дополнение к списку initializer_list передавать параметр типа ErrCode следующим образом:

void error_msg(ErrCode е, initializer_list il) {

 cout << e.msg() << ": ";

 for (const auto &elem : il)

  cout << elem << " ";

 cout << endl;

}

Поскольку класс initializer_list имеет члены begin() и end(), мы можем использовать для обработки элементов серийный оператор for (см. раздел 5.4.3). Эта программа, как и предыдущая версия, перебирает элементы заключенного в фигурные скобки списка значений, переданных параметру il.

Для этой версии необходимо пересмотреть вызовы так, чтобы передать аргумент типа ErrCode:

if (expected != actual)

 error_msg(ErrCode(42), {"functionX", expected, actual});

else

 error_msg(ErrCode(0), {"functionX", "okay"});

#books.png Параметр в виде многоточия

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

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

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

void foo(parm_list, ...);

void foo(...);

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

Упражнения раздела 6.2.6

Упражнение 6.27. Напишите функцию, получающую параметр типа initializer_list и возвращающую сумму элементов списка.

Упражнение 6.28. Во второй версии функции error_msg(), где у нее есть параметр типа ErrCode, каков тип элемента в цикле for?

Упражнение 6.29. При использовании типа initializer_list в серийном операторе for использовали бы вы ссылку как управляющую переменную цикла? Объясните почему.

 

Оператор return завершает выполнение функции и возвращает управление той функции, которая вызвала текущую. Существуют две формы оператора return:

return;

return выражение ;

 

6.3.1. Функции без возвращаемого значения

Оператор return без значения применим только в такой функции, типом возвращаемого значения которой объявлен void. Функции, возвращаемым типом которых объявлен void, необязательно должны содержать оператор return. В функции типа void оператор return неявно размещается после последнего оператора.

Как правило, функции типа void используют оператор return для преждевременного завершения выполнения. Это аналогично использованию оператора break (см. раздел 5.5.1) для выход из цикла. Например, можно написать функцию swap(), которая не делает ничего, если значения идентичны:

void swap(int &v1, int &v2) {

 // если значения равны, их замена не нужна; можно выйти сразу

 if (v1 == v2)

  return;

 // если мы здесь, придется поработать

 int tmp = v2;

 v2 = v1;

 v1 = tmp;

 // явно указывать оператор return не обязательно

}

Сначала эта функция проверяет, не равны ли значения, и если это так, то завершает работу. Если значения не равны, функция меняет их местами. После последнего оператора присвоения осуществляется неявный выход из функции.

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

 

6.3.2. Функции, возвращающие значение

Вторая форма оператора return предназначена для возвращения результата из функции. Каждый случай возвращения значения типа, отличного от void, должен возвратить значение. Возвращаемое значение должно иметь тип, либо совпадающий, либо допускающий неявное преобразование (см. раздел 4.11) в тип, указанный для возвращаемого значения функции при определении.

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

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

bool str_subrange(const string &str1, const string &str2) {

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

 if (str1.size() == str2.size())

  return str1 == str2; // ok: == возвращает bool

 // найти размер меньшей строки; условный оператор см. раздел 4.7

 auto size = (str1.size() < str2.size())

             ? str1.size() : str2.size();

 // просмотреть все элементы до размера меньшей строки

 for (decltype(size) i = 0; i != size; ++i) {

  if (str1[i] != str2[i])

   return; // ошибка #1: нет возвращаемого значения; компилятор

           // должен обнаружить эту ошибку

 }

 // ошибка #2: выполнение может дойти до конца функции, так и

 // не встретив оператор return

 // компилятор может и не обнаружить эту ошибку

}

Оператор return в цикле for является ошибочным потому, что он не в состоянии вернуть значение. Эту ошибку компилятор должен обнаружить.

Вторая ошибка заключается в том, что функция не имеет оператора return после цикла. Если произойдет вызов этой функции со строкой, являющейся подмножеством другой, процесс выполнения минует цикл for. Однако оператор return для этого случая не предусмотрен. Эту ошибку компилятор может и не обнаружить. В этом случае поведение программы во время выполнения будет непредсказуемо.

Отсутствие оператора return после цикла, который этот оператор содержит, является особенно коварной ошибкой. Однако большинство компиляторов ее не обнаружит.

Как возвращаются значения

Значения функций возвращаются тем же способом, каким инициализируются переменные и параметры: возвращаемое значение используется для инициализации временного объекта в точке вызова, и этот временный объект является результатом вызова функции.

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

// возвратить множественную форму слова, если ctr больше 1

string make_plural(size_t ctr, const string &word,

                   const string &ending) {

 return (ctr > 1) ? word + ending : word;

}

Тип возвращаемого значения этой функции — string, это значит, что возвращаемое значение копируется в точке вызова. Функция возвращает копию значения word или безымянную временную строку, полученную конкатенацией word и ending.

Когда функция возвращает ссылку, она, подобно любой другой ссылке, является только другим именем для объекта, на который ссылается. Рассмотрим, например, функцию, возвращающую ссылку на более короткую из двух переданный ей строк:

// возвратить ссылку на строку, которая короче

const string &shorterString(const string &s1, const string &s2) {

 return s1.size() <= s2.size() ? s1 : s2;

}

Параметры и возвращаемое значение имеют тип ссылки на const string. Строки не копируются ни при вызове функции, ни при возвращении результата.

Никогда не возвращайте ссылку на локальный объект

По завершении работы функции все хранилища ее локальных объектов освобождаются (см. раздел 6.1.1). Поэтому после завершения работы функции ссылки на ее локальные объекты ссылаются на несуществующие объекты.

// катастрофа: функция возвращает ссылку на локальный объект

const string &manip() {

 string ret;

 // обработать ret некоторым образом

 if (!ret.empty())

  return ret; // ошибка: возвращение ссылки на локальный объект!

 else

  return "Empty"; // ошибка: "Empty" - локальная временная строка

}

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

Оба оператора return возвращают здесь неопределенное значение — неизвестно, что будет, попробуй мы использовать значение, возвращенное функцией manip(). В первом операторе return очевидно, что функция пытается вернуть ссылку на локальный объект. Во втором случае строковый литерал преобразуется в локальный временный объект класса string. Этот объект, как и строка s, является локальным объектом функции manip(). Область памяти, в которой располагается временный объект, освобождается по завершении функции. Оба оператора return возвращают ссылки на области памяти, которые больше недоступны.

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

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

Функции, возвращающие типы класса и оператор вызова

Подобно любому оператору, оператор вызова обладает порядком (ассоциативностью) и приоритетом (см. раздел 4.1.2). У оператора вызова тот же приоритет, что и у операторов "точка" и "стрелка" (см. раздел 4.6). Как и эти операторы, оператор вызова имеет левосторонний порядок. В результате, если функция возвращает указатель, ссылку или объект типа класса, результат вызова можно использовать для обращения к члену полученного объекта.

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

// обращение к методу size объекта строки, возвращенной shorterString

auto sz = shorterString(s1, s2).size();

Поскольку эти операторы имеют левосторонний порядок, результат вызова функции shorterString() будет левым операндом точечного оператора. Этот оператор выбирает метод size() объекта строки. Этот метод становится левым операндом второго оператора вызова.

Возвращаемая ссылка является l-значением

Является ли вызов функции l-значением (см. раздел 4.1.1), зависит от типа возвращаемого значения функции. Вызовы функции, возвращающей ссылку, являются l-значением; другие типы возвращаемого значения являются r-значениями. Вызов функции, возвращающей ссылку, применяется таким же способом, как и любое другое l-значение. В частности, можно осуществлять присвоение результату вызова функции, возвращающей ссылку на неконстанту:

char &get_val(string &str, string::size_type ix) {

 return str[ix]; // get_val подразумевает, что данный индекс допустим

}

int main() {

 string s("a value");

 cout << s << endl;   // отображает значение

 get_val(s, 0) = 'A'; // изменяет s[0] на A

 cout << s << endl;   // отображает значение A

 return 0;

}

Может быть несколько странно видеть вызов функции слева от оператора присвоения. Однако в этом нет ничего необычного. Возвращаемое значение — ссылка, поэтому вызов — это l-значение, а любое l-значение может быть левым операндом оператора присвоения.

Если тип возвращаемого значения является ссылкой на константу, то (как обычно) присвоение результату вызова невозможно:

shorterString("hi", "bye") = "X"; // ошибка: возвращаемое значение

                                  // является константой

Списочная инициализация возвращаемого значения

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

Для примера вернемся к функции error_msg из раздел 6.2.6. Эта функция получала переменное количество строковых аргументов и выводило сообщение об ошибке, составленное из переданных строк. Теперь вместо вызова функции error_msg() мы возвратим вектор, содержащий строки сообщений об ошибке:

vector process() {

 // ...

 // expected и actual - строки

 if (expected.empty())

  return {}; // возвратить пустой вектор

 else if (expected == actual)

  return {"functionX", "okay"}; // возвратить вектор

                                // инициализированный списком

 else

  return {"functionX", expected, actual};

}

В первом операторе return возвращается пустой список. В данном случае возвращенный обработанный вектор будет пуст. В противном случае возвращается вектор, инициализированный двумя или тремя элементами, в зависимости от того, равны ли expected и actual.

У функции, возвращающей встроенный тип, заключенный в скобки список может содержать хотя бы одно значение, и это значение не должно требовать сужающего преобразования (см. раздел 2.2.1). Если функция возвращает тип класса, то используемые инициализаторы определяет сам класс (см. раздел 3.3.1).

Возвращение значения из функции main()

Есть одно исключение из правила, согласно которому функция с типом возвращаемого значения, отличного от void, обязана возвратить значение: функция main() может завершить работу без возвращения значения. Если процесс выполнения достигает конца функции main() и нет никакого значения для возвращения, компилятор неявно добавляет возвращение значения 0.

Как упоминалось в разделе 1.1, значение, возвращаемое из функции main(), рассматривается как индикатор состояния. Возвращение нулевого значения означает успех; большинство других значений — неудачу. У значения, отличного от нуля, есть машинно-зависимое значение. Чтобы сделать его независимым от машины, заголовок cstdlib определяет две переменные препроцессора (см. раздел 2.3.2), которые можно использовать для индикации успеха или отказа:

int main() {

 if (some failure)

  return EXIT_FAILURE; // определено в cstdlib

 else

  return EXIT_SUCCESS; // определено в cstdlib

}

Поскольку это переменные препроцессора, им не должна предшествовать часть std:: и их нельзя использовать в объявлениях using.

Рекурсия

Функция, которая вызывает себя прямо или косвенно, является рекурсивной функцией (recursive function). В качестве примера можно переписать функцию вычисления факториала так, чтобы использовать рекурсию:

// вычислить val!, т.е. 1 * 2 * 3 ... * val

int factorial(int val) {

 if (val > 1)

  return factorial(val-1) * val;

 return 1;

}

В этой реализации осуществляется рекурсивный вызов функции factorial(), чтобы вычислить факториал числа, начиная со значения, первоначально переданного val, и далее в обратном порядке. Когда значение val достигнет 1, рекурсия останавливается и возвращается значение 1.

В рекурсивной функции всегда должно быть определено условие выхода или останова (stopping condition); в противном случае рекурсия станет бесконечной, т.е. функция продолжит вызывать себя до тех пор, пока стек программы не будет исчерпан. Иногда эта ошибка называется бесконечной рекурсией (infinite recursion). В случае функции factorial() условием выхода является равенство значения параметра val единице.

Ниже приведена трассировка выполнения функции factorial() при передаче ей значения 5.

Трассировка вызова функции factorial(5)

Функция main() не может вызывать сама себя.

Упражнения раздела 6.3.2

Упражнение 6.30. Откомпилируйте версию функции str_subrange(), представленной в начале раздела, и посмотрите, что ваш компилятор делает с указанными сообщениями об ошибках.

Упражнение 6.31. Когда допустимо возвращение ссылки? Когда ссылки на константу?

Упражнение 6.32. Укажите, корректна ли следующая функция. Если да, то объясните, что она делает; в противном случае исправьте ошибки, а затем объясните все.

int &get(int *arry, int index) { return arry[index]; }

int main() {

 int ia[10];

 for (int i = 0; i != 10; ++i)

  get(ia, i) = i;

}

Упражнение 6.33. Напишите рекурсивную функцию, выводящую содержимое вектора.

Упражнение 6.34. Что случится, если условие остановки функции factorial() будет таким:

if (val != 0)

Упражнение 6.35. Почему в вызове функции factorial() мы передали val-1, а не val--?

 

6.3.3. Возвращение указателя на массив

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

typedef int arrT[10];  // arrT синоним для типа массива из десяти

                       // целых чисел

using arrtT = int[10]; // эквивалентное объявление arrT;

                       // см. раздел 2.5.1

arrT* func(int i);     // func возвращает указатель на массив из

                       // пяти целых чисел

где arrT — это синоним для массива из десяти целых чисел. Поскольку нельзя возвратить массив, мы определяем тип возвращаемого значения как указатель на этот тип. Таким образом, функция func() получает один аргумент типа int и возвращает указатель на массив из десяти целых чисел.

Объявление функции, возвращающей указатель на массив

Чтобы объявить функцию func(), не используя псевдоним типа, следует вспомнить, что размерность массива следует за определяемым именем:

int arr[10];          // arr массив из десяти целых чисел

int *p1[10];          // p1 массив из десяти указателей

int (*p2)[10] = &arr; // p2 указывает на массив из десяти целых чисел

Подобно этим объявлениям, если необходимо определить функцию, которая возвращает указатель на массив, размерность должна следовать за именем функции. Однако функция имеет список параметров, который также следует за именем. Список параметров предшествует размерности. Следовательно, функция, которая возвращает указатель на массив, имеет такую форму:

Тип (* функция ( список_параметров ))[ размерность ]

Как и в любом другом объявлении массива, Тип — это тип элементов, а размерность — это размер массива. Круглые скобки вокруг части (* функция ( список_параметров )) необходимы по той же причине, по которой они были нужны при определили указателя p2. Без них мы определили бы функцию, которая возвращает массив указателей.

В качестве конкретного примера рассмотрим следующее объявление функции func(), не использующей псевдоним типа:

int (*func(int i))[10];

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

• func(int) указывает, что функцию func() можно вызвать с аргументом типа int;

• (*func(int)) указывает, что можно обратиться к значению результата этого вызова;

• (*func(int))[10] указывает, что обращение к значению результата вызова функции func() возвращает массив из десяти элементов;

• int (*func(int))[10] указывает, что типом элементов этого массива является int.

Использование замыкающего типа возвращаемого значения

По новому стандарту есть и другой способ упростить объявления функции func() — с использованием замыкающего типа возвращаемого значения (trailing return type). Оно может быть определено для любой функции, но полезней всего оно для функций со сложными типами возвращаемого значения, такими как указатели (или ссылки) на массивы. Замыкающий тип возвращаемого значения следует за списком параметров и предваряется символом ->. Чтобы сообщить о том, что возвращаемое значение следует за списком параметров, ключевое слово auto располагается там, где обычно присутствует тип возвращаемого значения:

// fcn получает аргумент типа int и возвращает указатель на массив

// из десяти целых чисел

auto func(int i) -> int(*)[10];

Поскольку тип возвращаемого значения указан после списка параметров, проще заметить, что функция func() возвращает указатель и что этот указатель указывает на массив из десяти целых чисел.

Использование спецификатора decltype

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

int odd[] = {1,3,5,7,9};

int even[] = {0,2,4,6,8};

// возвращает указатель на массив из пяти элементов типа int

decltype(odd) *arrPtr(int i) {

 return (i % 2) ? &odd : &even; // возвращает указатель на массив

}

Тип возвращаемого значения функции arrPtr() указан как decltype, свидетельствуя о том, что функция возвращает указатель на любой тип, который имеет odd. В данном случае этот объект является массивом, поэтому функция arrPtr() возвращает указатель на массив из пяти целых чисел.

Единственная сложность здесь в том, что следует помнить, что спецификатор decltype не преобразовывает автоматически массив в указатель соответствующего ему типа. Тип, возвращенный спецификатором decltype, является типом массива, для которого нужно добавить *, чтобы указать, что функция arrPtr() возвращает указатель.

Упражнения раздела 6.3.3

Упражнение 6.36. Напишите объявление функции, возвращающей ссылку на массив из десяти строк, не используя ни замыкающий тип возвращаемого значения, ни спецификатор decltype или псевдоним типа.

Упражнение 6.37. Напишите три дополнительных объявления для функций предыдущего упражнения. Нужно использовать псевдоним типа, замыкающий тип возвращаемого значения и спецификатор decltype. Какую форму вы предпочитаете и почему?

Упражнение 6.38. Перепишите функцию arrPtr() так, чтобы она возвращала ссылку на массив.

 

Функции, расположенные в одной области видимости, называются перегруженными (overloaded), если они имеют одинаковые имена, но разные списки параметров. Пример определения нескольких функций по имени print() приведен в разделе 6.2.4:

void print(const char *cp);

void print(const int *beg, const int *end);

void print(const int ia[], size_t size);

Эти функции выполняют одинаковое действие, но их параметры относятся к разным типам. При вызове такой функции компилятор принимает решение о применении конкретной версии на основании типа переданного аргумента:

int j[2]А также для временного отключения больших фрагментов кода при отладке. — Примеч. ред .
= {0, 1};

print("Hello World");        // вызов print (const char*)

print(j, end(j) - begin(j)); // вызов print(const int*, size_t)

print(begin(j), end(j));     // вызов print(const int*, const int*)

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

Функция main() не может быть перегружена.

Определение перегруженных функций

Рассмотрим приложение базы данных с несколькими функциями для поиска записи на основании имени, номера телефона, номер счета и т.д. Перегрузка функций позволит определить коллекцию функций, каждая по имени lookup(), которые отличаются тем, как они осуществляют поиск. Мы сможем вызвать функцию lookup(), передав значение любого из следующих типов:

Record lookup(const Account&); // поиск по счету

Record lookup(const Phone&);   // поиск по телефону

Record lookup(const Name&);    // поиск по имени

Account acct;

Phone phone;

Record r1 = lookup(acct);  // вызов версии, получающей Account

Record r2 = lookup(phone); // вызов версии, получающей Phone

Здесь у всех трех функций одинаковое имя, но все же это три разные функции. Чтобы выяснить, которую из них вызвать, компилятор использует тип (типы) аргументов.

Перегруженные функции должны отличаться по количеству или типу (типам) своих параметров. Каждая из функций выше получает один параметр, но типы у этих параметров разные.

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

Record lookup(const Account&);

bool lookup(const Account&); // ошибка: отличается только типом

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

Различие типов параметров

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

// каждая пара объявляет ту же функцию

Record lookup(const Account &acct);

Record lookup(const Account&); // имена параметров игнорируются

typedef Phone Telno;

Record lookup(const Phone&);

Record lookup(const Telno&);   // Telno и Phone того же типа

Первое объявление в первой паре именует свой параметр. Имена параметров предназначены только для документирования. Они не изменяют список параметров.

Во второй паре типы только выглядят разными, Telno — не новый тип, это только синоним типа Phone. Псевдоним типа (см. раздел 2.5.1) предоставляет альтернативное имя для уже существующего типа, а не создает новый тип. Поэтому два параметра, отличающиеся только тем, что один использует имя типа, а другой его псевдоним, не являются разными.

#magnify.png Перегрузка и константные параметры

Как упоминалось в разделе 6.2.3, спецификатор const верхнего уровня (см. раздел 2.4.3) никак не влияет на объекты, которые могут быть переданы функции. Параметр, у которого есть спецификатор const верхнего уровня, неотличим от такового без спецификатора const верхнего уровня:

Record lookup(Phone);

Record lookup(const Phone);  // повторно объявляет Record lookup(Phone)

Record lookup(Phone*);

Record lookup(Phone* const); // повторно объявляет

                             //  Record lookup(Phone*)

Здесь вторые объявления повторно объявляет ту же функцию, что и первые. С другой стороны, функцию можно перегрузить на основании того, является ли параметр ссылкой (или указателем) на константную или неконстантную версию того же типа; речь идет о спецификаторе const нижнего уровня:

// функции, получающие константную и неконстантную ссылку (или

// указатель), имеют разные параметры

Record lookup(Account&);       // функция получает ссылку на Account

Record lookup(const Account&); // новая функция получает константную

                               // ссылку

Record lookup(Account*);       // новая функция получает указатель

                               // на Account

Record lookup(const Account*); // новая функция получает указатель на

                               // константу

В этих случаях компилятор может использовать константность аргумента, чтобы различить, какую функцию применять. Поскольку нет преобразования (см. раздел 4.11.2) из константы, можно передать константный объект (или указатель на константу) только версии с константным параметром. Так как преобразование в константу возможно, можно вызвать функцию и неконстантного объекта, и указателя на неконстантный объект. Однако, как будет представлено в разделе 6.6.1, компилятор предпочтет неконстантные версии при передаче неконстантного объекта или указателя на неконстантный объект.

Совет. Когда не следует перегружать функции

Хотя перегрузка функций позволяет избежать необходимости создавать и запоминать имена общепринятых операций, она не всегда целесообразна. В некоторых случаях разные имена функций предоставляют дополнительную информацию, которая упрощает понимание программы. Давайте рассмотрим набор функций-членов класса Screen , отвечающих за перемещение курсора.

Screen& moveHome();

Screen& moveAbs(int, int);

Screen& moveRel(int, int, string direction);

На первый взгляд может показаться, что этот набор функций имеет смысл перегрузить под именем move :

Screen& move();

Screen& move(int, int);

Screen& move(int, int, string direction);

Однако при перегрузке этих функций мы потеряли информацию, которая была унаследована именами функции. Хотя перемещение курсора — это общая операция, совместно используемая всеми этими функциями, специфический характер перемещения уникален для каждой из этих функций. Рассмотрим, например, функцию moveHome() , осуществляющую вполне определенное перемещение курсора. Какое из двух приведенных ниже обращений понятнее при чтении кода?

// которая из записей понятней?

myScreen.moveHome(); // вероятно, эта!

myScreen.move();

Оператор const_cast и перегрузка

В разделе 4.11.3 упоминалось, что оператор const_cast особенно полезен в контексте перегруженных функций. В качестве примера вернемся к функции shorterString() из раздела 6.3.2:

// возвратить ссылку на строку, которая короче

const string &shorterString (const string &s1, const string &s2) {

 return s1.size() <= s2.size() ? s1 : s2;

}

Эта функция получает и возвращает ссылки на константную строку. Мы можем вызвать функцию с двумя неконстантными строковыми аргументами, но как результат получим ссылку на константную строку. Могла бы понадобиться версия функции shorterString(), которая, получив неконстантные аргументы, возвратит обычную ссылку. Мы можем написать эту версию функции, используя оператор const_cast:

string &shorterString(string &s1, string &s2) {

 auto &r = shorterString(const_cast(s1),

                         const_cast(s2));

 return const_cast(r);

}

Эта версия вызывает константную версию функции shorterString() при приведении типов ее аргументов к ссылкам на константу. Функция возвращает ссылку на тип const string, которая, как известно, привязана к одному из исходных, неконстантных аргументов. Следовательно, приведение этой строки назад к обычной ссылке string& при возвращении вполне безопасно.

Вызов перегруженной функции

Когда набор перегруженных функций определен, необходима возможность вызвать их с соответствующими аргументами. Подбор функции (function matching), известный также как поиск перегруженной функции (overload resolution), — это процесс, в ходе которого вызов функции ассоциируется с определенной версией из набора перегруженных функций. Компилятор определяет, какую именно версию функции использовать при вызове, сравнивая аргументы вызова с параметрами каждой функции в наборе.

Как правило, вовсе несложно выяснить, допустим ли вызов, и если он допустим, то какая из версий функции будет использована компилятором. Функции в наборе перегруженных версий отличаются количеством или типом аргументов. В таких случаях определить используемую функцию просто. Подбор функции усложняется в случае, когда количество параметров одинаково и они допускают преобразование (см. раздел 4.11) переданных аргументов. Распознавание вызовов компилятором при наличии преобразований рассматривается в разделе 6.6, а пока следует понять, что при любом вызове перегруженной функции возможен один из трех результатов.

• Компилятор находит одну функцию, которая является наилучшим соответствием (best match) для фактических аргументов, и создает код ее вызова.

• Компилятор не может найти ни одной функции, параметры которой соответствуют аргументам вызова. В этом случае компилятор сообщает об ошибке отсутствия соответствия (no match).

• Компилятор находит несколько функций, которые в принципе подходят, но ни одна из них не соответствует полностью. В этом случае компилятор также сообщает об ошибке, об ошибке неоднозначности вызова (ambiguous call).

Упражнения раздела 6.4

Упражнение 6.39. Объясните результат второго объявления в каждом из следующих наборов. Укажите, какое из них (если есть) недопустимо.

(a) int calc(int, int);

    int calc(const int, const int);

(b) int get();

    double get();

(c) int *reset(int *);

    double *reset(double *);

 

6.4.1. Перегрузка и область видимости

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

Новички в программировании на языке С++ зачастую не понимают взаимодействия между областью видимости и перегрузкой. Однако у перегрузки нет никаких специальных свойств относительно области видимости. Как обычно, если имя объявлено во внутренней области видимости, оно скрывает (hidden name) такое же имя, объявленное во внешней области видимости. Имена не перегружают в областях видимости:

string read();

void print(const string &);

void print(double); // перегружает функцию print

void fooBar(int ival) {

 bool read = false; // новая область видимости: скрывает

                    // предыдущее объявление имени read

 string s = read(); // ошибка: read - переменная типа bool, а не

                    // функция

 // плохой подход: обычно не следует объявлять функции в локальной

 // области видимости

 void print(int);  // новая область видимости: скрывает предыдущие

                   // экземпляры функции print

 print("Value: "); // ошибка: print(const string &) скрыта

 print(ival);      // ok: print (int) видима

 print(3.14);      // ok: вызов print(int); print(double) скрыта

}

Большинство читателей не удивит ошибка при вызове функции read(). Когда компилятор обрабатывает вызов функции read(), он находит локальное определение имени read. Это имя принадлежит переменной типа bool, а не функции. Следовательно, вызов некорректен.

Точно тот же процесс используется при распознавании вызова функции print(). Объявление print(int) в функции fooBar скрывает прежнее ее объявление. В результате будет доступна только одна функция print(), та, которая получает один параметр типа int.

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

В языке С++ поиск имени осуществляется до проверки соответствия типов.

Первый вызов передает функции print() строковый литерал, но единственное ее объявление, находящееся в области видимости, имеет параметр типа int. Строковый литерал не может быть преобразован в тип int, поэтому вызов ошибочен. Функция print(const string&), которая соответствовала бы этому вызову, скрыта и не рассматривается.

Когда происходит вызов функции print() с передачей аргумента типа double(), процесс повторяется. Компилятор находит локальное определение функции print(int). Но аргумент типа double может быть преобразован в значение типа int, поэтому вызов корректен.

Если бы объявление print(int) находилось в той же области видимости, что и объявления других версий функции print(), это была бы еще одна ее перегруженная версия. В этом случае вызовы распознавались бы по-другому, поскольку компилятор видел бы все три функции:

void print(const string &);

void print(double); // перегружает функцию print

void print(int);    // еще один экземпляр перегрузки

void fooBar2(int ival) {

 print("Value: "); // вызов print(const string &)

 print(ival);      // вызов print(int)

 print(3.14);      // вызов print(double)

}

 

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

 

6.5.1. Аргументы по умолчанию

Параметры некоторых функций могут обладать конкретными значениями, используемыми в большинстве, но не во всех вызовах. Такие обычно используемые значения называют аргументом по умолчанию (default argument). Функции с аргументами по умолчанию могут быть вызваны с ними или без них.

Например, для представления содержимого окна можно было бы использовать тип string. Мы могли бы хотеть, чтобы по умолчанию у окна была определенная высота, ширина и фоновый символ. Но мы могли бы также захотеть позволить пользователям использовать собственные значения, кроме значений по умолчанию. Чтобы приспособить и значение по умолчанию, и определяемое пользователем, мы объявили бы функцию, представляющую окно, следующим образом:

typedef string::size_type sz; // typedef см. p. 2.5.1

string screen(sz ht = 24, sz wid = 80, char backgrnd = ' ');

Здесь мы предоставили для каждого параметра значение по умолчанию. Аргумент по умолчанию определяется как инициализатор параметра в списке параметров. Значения по умолчанию можно определить как для одного, так и для нескольких параметров. Но если у параметра есть аргумент по умолчанию, то все параметры, следующие за ним, также должны иметь аргументы по умолчанию.

Вызов функции с аргументами по умолчанию

Если необходимо использовать аргумент по умолчанию, его значение при вызове функции пропускают. Поскольку функция screen() предоставляет значения по умолчанию для всех параметров, мы можем вызвать ее без аргументов, с одним, двумя или тремя аргументами:

string window;

window = screen();             // эквивалент screen(24, 80, ' ')

window = screen(66);           // эквивалент screen(66, 80, ' ')

window = screen(66, 256);      // screen(66, 256, ' ')

window = screen(66, 256, '#'); // screen(66, 256, '#')

Аргументы в вызове распознаются по позиции. Значения по умолчанию используются для аргументов, крайних справа. Например, чтобы переопределить значение по умолчанию параметра background, следует поставить также аргументы для параметров height и width:

window = screen(, , '?'); // ошибка: можно пропустить аргументы только

                          // крайние справа

window = screen('?');     // вызов screen('?', 80, ' ')

Обратите внимание, что второй вызов, передающий одно символьное значение, вполне допустим. Несмотря на допустимость, это вряд ли то, что ожидалось. Вызов допустим потому, что символ '?' имеет тип char, а он может быть преобразован в тип крайнего левого параметра. Это параметр типа string::size_type, который является целочисленным беззнаковым типом. В этом вызове аргумент типа char неявно преобразуется в тип string::size_type и передается как аргумент параметру height. На машине авторов символ '?' имеет шестнадцатеричное значение 0x3F, соответствующее десятичному 63. Таким образом, этот вызов присваивает параметру height значение 63.

Одной из задач при разработке функции с аргументами по умолчанию является упорядочивание параметров так, чтобы те из них, для которых использование значения по умолчанию вероятней всего, располагались последними.

Объявление аргумента по умолчанию

Хотя вполне обычной практикой является объявление функции однажды в заголовке, вполне допустимо многократно объявлять ее повторно. Однако у каждого параметра может быть свое значение по умолчанию, определенное только однажды в данной области видимости. Таким образом, любое последующее объявление может добавить значение по умолчанию только для того параметра, у которого ранее не было определено значение по умолчанию. Как обычно, значения по умолчанию могут быть определены, только если у всех параметров справа уже есть значения по умолчанию. Рассмотрим следующий пример:

// у параметров height и width нет значений по умолчанию

string screen(sz, sz, char = ' ');

Нельзя изменить уже заявленное значение по умолчанию:

string screen(sz, sz, char = '*'); // ошибка: переобъявление

Но можно добавить аргумент по умолчанию следующим образом:

string screen(sz = 24, sz = 80, char); // ok: добавление аргументов

                                       // по умолчанию

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

Инициализация аргумента по умолчанию

Локальные переменные не могут использоваться как аргумент по умолчанию. За исключением этого ограничения, аргумент по умолчанию может быть любым выражением, тип которого приводим к типу параметра:

// объявления wd, def и ht должны располагаться вне функции

sz wd = 80;

char def = ' ';

sz ht();

string screen(sz = ht(), sz = wd, char = def);

string window = screen(); // вызов screen(ht(), 80, ' ')

Поиск имен, используемых для аргументов по умолчанию, осуществляется в пределах объявления функции. Значения, представляемые этими именами, вычисляются во время вызова:

void f2() {

 def = '*';   // изменение значения аргумента по умолчанию

 sz wd = 100; // скрывает внешнее определение wd, но не изменяет

              // значение по умолчанию

 window = screen(); // вызов screen(ht(), 80, '*')

}

В функции f2() было изменено значение def. Вызов функции screen передает это измененное значение. Эта функция также объявляет локальную переменную, которая скрывает внешнюю переменную wd. Однако локальное имя wd никак не связано с аргументом по умолчанию, переданным функции screen().

Упражнения раздела 6.5.1

Упражнение 6.40. Какое из следующих объявлений (если оно есть) содержит ошибку? Почему?

(a) int ff(int a, int b = 0, int с = 0);

(b) char *init(int ht = 24, int wd, char bckgrnd);

Упражнение 6.41. Какие из следующих вызовов (если они есть) недопустимы? Почему? Какие из них допустимы (если они есть), но, вероятно, не соответствуют намерениям разработчика? Почему?

char *init(int ht, int wd = 80, char bckgrnd = ' ');

(a) init(); (b) init(24,10); (c) init(14, '*');

Упражнение 6.42. Присвойте второму параметру функции make_plural() (см. раздел 6.3.2) аргумент по умолчанию 's'. Проверьте программу, выведя слова "success" и "failure" в единственном и множественном числе.

 

6.5.2. Встраиваемые функции и функции

constexpr

В разделе 6.3.2 приведена небольшая функция, возвращающая ссылку на более короткую строку из двух переданных ей. К преимуществам определения функции для такой маленькой операции относятся следующие.

• Обращение к функции shorterString() проще и понятнее, чем эквивалентное условное выражение.

• Использование функции гарантирует одинаковое поведение. Она гарантирует, что каждая проверка будет выполнена тем же способом.

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

• Функция может быть многократно использована при написании других приложений.

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

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

Содержимое функции, объявленной встраиваемой (inline) при компиляции, как правило, встраивается по месту вызова. Предположим, что функция shorterString() объявлена встраиваемой, а ее вызов имеет такой вид:

cout << shorterString(s1, s2) << endl;

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

cout << (s1.size() < s2.size() ? s1 : s2) << endl;

Таким образом, во время выполнения удастся избежать дополнительных затрат, связанных с вызовом функции shorterString().

Чтобы объявить функцию shorterString() встраиваемой, в определении, перед типом возвращаемого значения, располагают ключевое слово inline.

// встраиваемая версия функции сравнения двух строк

inline const string &

shorterString(const string &s1, const string &s2) {

 return s1.size() <= s2.size() ? s1 : s2;

}

Объявление функции встраиваемой является только рекомендацией компилятору. Компилятор вполне может проигнорировать эту рекомендацию.

На самом деле механизм встраивания применяется в процессе оптимизации объектного кода, в ходе которого код небольших функций, вызов которых происходит достаточно часто, встраивается по месту вызова. Большинство компиляторов не будет встраивать рекурсивные функции. Функция на 75 строк также, вероятно, не будет встроена.

Функции constexpr

Функция constexpr — это функция, которая может быть применена в константном выражении (см. раздел 2.4.4). Функция constexpr определяется как любая другая функция, но должна соответствовать определенным ограничениям: возвращаемый тип и тип каждого параметра должны быть литералами (см. раздел 2.4.4), тело функции должно содержать только один оператор return:

constexpr int new_sz() { return 42; }

constexpr int foo = new_sz(); // ok: foo - константное выражение 

Здесь функция new_sz определена как constexpr, она не получает никаких аргументов. Компилятор может проверить (во время компиляции), что вызов функции new_sz() возвращает константное выражение, поэтому ее можно использовать для инициализации переменной constexpr по имени foo.

Если это возможно, компилятор заменит вызов функции constexpr ее результирующим значением. Для этого функция constexpr неявно считается встраиваемой.

Тело функции constexpr может содержать другие операторы, если они не выполняют действий во время выполнения. Например, функция constexpr может содержать пустые операторы, псевдонимы типа (см. раздел 2.5.1) и объявления using.

Функции constexpr позволено возвратить значение, которое не является константой:

// scale(arg) - константное выражение, если arg - константное выражение

constexpr size_t scale(size_t cnt) { return new_sz() * cnt; }

Функция scale() возвратит константное выражение, если ее аргумент будет константным выражением, но не в противном случае:

int arr[scale(2)]; // ok: scale(2) - константное выражение

int i = 2;         // i - неконстантное выражение

int a2[scale(i)];  // ошибка: scale(i) - неконстантное выражение

Если передать константное выражение (такое как литерал 2), возвращается тоже константное выражение. В данном случае компилятор заменит вызов функции scale() результирующим значением.

Если происходит вызов функции scale() с выражением, которое не является константным (например, объект i типа int), то возвращается неконстантное выражение. Если использовать функцию scale() в контексте, требующем константного выражения, компилятор проверит, является ли результат константным выражением. Если это не так, то компилятор выдаст сообщение об ошибке.

Функция constexpr не обязана возвращать константное выражение.

Помещайте встраиваемые функции и функции constexpr в файлы заголовка

В отличие от других функций, встраиваемые функции и функции constexpr могут быть определены в программе несколько раз. В конце концов, чтобы встроить код, компилятор нуждается в определении, а не только в объявлении. Однако все определения конкретной встраиваемой функции и функции constexpr должны совпадать точно. В результате встраиваемые функции и функции constexpr обычно определяют в заголовках.

Упражнения раздела 6.5.2

Упражнение 6.43. Какое из следующих объявлений и определений имеет смысл поместить в файл заголовка, а какой — в текст файла исходного кода? Объясните почему.

(a) inline bool eq(const BigInt&, const BigInt&) {...}

(b) void putValues(int *arr, int size);

Упражнение 6.44. Перепишите функцию isShorter() из раздела 6.2.2 как встраиваемую.

Упражнение 6.45. Пересмотрите функции, написанные для предыдущих упражнений, и решите, должны ли они быть определены как встраиваемые. Если да, то сделайте это. В противном случае объясните, почему они не должны быть встраиваемыми.

Упражнение 6.46. Возможно ли определить функцию isShorter как constexpr? Если да, то сделайте это. В противном случае объясните, почему нет.

 

6.5.3. Помощь в отладке

Для условного выполнения отладочного кода программисты С++ иногда используют подход, подобный защите заголовка (см. раздел 2.6.3). Идея в том, что программа будет содержать отладочный код, который выполняется только во время разработки программы. Когда приложение закончено и готово к выпуску, отладочный код исключается. Этот подход подразумевает использование двух средств препроцессора: assert и NDEBUG.

Макрос препроцессора assert

Макросassert — это макрос препроцессора (preprocessor macro). Макрос препроцессора — это переменная препроцессора, действующая как встраиваемая функция. Макрос assert получает одно выражение и использует его как условие:

assert(выражение);

Если результат выражения ложь (т.е. нуль), то макрос assert выдает сообщение и закрывает программу. Если результат выражения — истина (т.е. он отличен от нуля), то макрос assert не делает ничего.

Действие макроса препроцессора подобно вызову функции. Макрос assert получает одно выражение, которое он использует как условие.

Макрос assert определен в заголовке cassert. Как уже упоминалось, относящиеся к препроцессору имена обрабатывает препроцессор, а не компилятор (см. раздел 2.3.2). В результате такие имена можно использовать непосредственно, без объявления using. Таким образом, используется имя assert, а не std::assert, кроме того, для него не предоставляется объявление using.

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

assert(word.size() > threshold);

Переменная препроцессора NDEBUG

Поведение макроса assert зависит от состояния переменной препроцессора NDEBUG. Если переменная NDEBUG определена, макрос assert ничего не делает. По умолчанию переменная NDEBUG не определена, поэтому по умолчанию макрос assert выполняет проверку.

Отладку можно "выключить", предоставив директиву #define, определяющую переменную NDEBUG. В качестве альтернативы большинство компиляторов предоставляет параметр командной строки, позволяющий определять переменные препроцессора:

$ CC -D NDEBUG main.С # use /D with the Microsoft compiler

Результат будет тот же, что и при наличии строки #define NDEBUG в начале файла main.С.

Когда переменная NDEBUG определена, программа во время выполнения избегает дополнительных затрат на проверку различных условий. Самих проверок во время выполнения, конечно, тоже не будет. Поэтому макрос assert следует использовать только для проверки того, что действительно недопустимо. Это может быть полезно при отладке программы, но не должно использоваться для замены логических проверок времени выполнения или проверки ошибок, которые должна осуществлять программа.

В дополнение к макросу assert можно написать собственный отладочный код, выполняющийся в зависимости от переменной NDEBUG. Если переменная NDEBUG не определена, код между директивами #ifndef и #endif выполняется, а в противном случае игнорируется:

void print(const int ia[], size_t size) {

#ifndef NDEBUG

// __func__ - локальная статическая переменная, определенная

// компилятором. Она содержит имя функции

cerr << __func__ << ": array size is " << size << endl;

#endif

// ...

Здесь переменная __func__ используется для вывода имени отлаживаемой функции. Компилятор определяет переменную __func__ в каждой функции. Это локальный статический массив типа const char, содержащий имя функции.

Кроме переменной __func__, определяемой компилятором С++, препроцессор определяет четыре других имени, которые также могут пригодиться при отладке:

__FILE__ строковый литерал, содержащий имя файла.

__LINE__ целочисленный литерал, содержащий номер текущий строки.

__TIME__ строковый литерал, содержащий файл и время компиляции.

__DATE__ строковый литерал, содержащий файл и дату компиляции.

Эти константы можно использовать для отображения дополнительной информации в сообщениях об ошибках:

if (word.size() < threshold)

 cerr << "Error: " << __FILE__

      << " : in function " << __func__

      << " at line " << __LINE__ << endl

      << " Compiled on " << __DATE__

      << " at " << __TIME__ << endl

      << " Word read was \"" << word << "\": Length too short" << endl;

Если передать этой программе строку, которая короче threshold, то будет создано следующее сообщение об ошибке:

Error: wdebug.cc : in function main at line 27

       Compiled on Jul 11 2012 at 20:50:03

       Word read was "foo": Length too short

Упражнения раздела 6.5.3

Упражнение 6.47. Пересмотрите программу, написанную в упражнении раздела 6.3.2, где использовалась рекурсия для отображения содержимого вектора так, чтобы условно отображать информацию о ее выполнении. Например, отобразите размер вектора при каждом вызове. Откомпилируйте и запустите программу с включенной отладкой и с выключенной.

Упражнение 6.48. Объясните, что делает этот цикл и стоит ли использовать в нем макрос assert:

string s;

while (cin >> s && s != sought) { } // пустое тело

assert(cin);

 

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

void f() ;

void f(int) ;

void f(int, int);

void f(double, double = 3.14);

f(5.6); // вызов void f(double, double)

Выявление кандидатов и подходящих функций

На первом этапе подбора перегруженной функции выявляют набор версий, подходящих для рассматриваемого вызова. Такие функции называются функциями-кандидатами (candidate function). Функция-кандидат имеет имя, указанное при вызове, и видима в точке вызова. В данном примере кандидатами являются все четыре функции по имени f.

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

При вызове f(5.6) две функции-кандидата можно исключить сразу из-за несоответствия количеству аргументов. Речь идет о версии без параметров и версии с двумя параметрами типа int. В данном случае вызов имеет только один аргумент, а эти функции не имеют их вообще или имеют два параметра соответственно.

Функция, получающая один аргумент типа int, и функция, получающая два аргумента типа double, могли бы быть подходящими. Любая из них может быть вызвана с одним аргументом. Функция, получающая два аргумента типа double, имеет аргумент по умолчанию, а значит, может быть вызвана с одним аргументом.

Когда у функции есть аргументы по умолчанию (см. раздел 6.5.1), при вызове может быть передано меньше аргументов, чем она фактически имеет.

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

• Функция f(int) является подходящей потому, что аргумент типа double может быть неявно преобразован в параметр типа int.

• Функция f(double, double) также является подходящей потому, что для второго параметра задано значение по умолчанию, а первый параметр имеет тип double, который точно соответствует типу аргумента.

Если никаких подходящих функций не обнаружено, компилятор выдает сообщение об ошибке.

Поиск наилучшего соответствия, если он есть

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

В данном случае существует только один (явный) аргумент, который имеет тип double. При вызове версии f(int) аргумент преобразуется из типа double в тип int. Вторая подходящая функция, f(double, double), точно соответствует типу этого аргумента. Поскольку точное соответствие лучше соответствия требующего преобразования, компилятор предпочитает версию с двумя параметрами типа double. Для второго, недостающего аргумента компилятор добавит аргумент по умолчанию.

Подбор перегруженной версии с несколькими параметрами

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

f(42, 2.56);

Набор подходящих функций выявляется, как прежде. Компилятор выбирает те версии функции, которые имеют необходимое количество параметров, типы которых соответствуют типам аргументов. В данном случае в набор подходящих вошли функции f(int, int) и f(double, double). Затем компилятор перебирает аргументы один за одним и определяет, какая из версий функций имеет наилучшее соответствие. Наилучше соответствующая функция та, для которой единственной выполняются следующие условия.

• Соответствие по каждому аргументу не хуже, чем у остальных подходящих функций.

• По крайней мере у одного аргумента соответствие лучше, чем у остальных подходящих функций.

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

В рассматриваемом примере вызова анализ лишь первого аргумента для версии f(int, int) функции f() обнаруживает точное соответствие. При анализе второй версии функции f() оказывается, что аргумент 42 типа int следует преобразовать в значение типа double. Соответствие в результате встроенного преобразования хуже, чем точное. Таким образом, рассматривая только этот параметр, лучше соответствует та версия функции f(), которая обладает двумя параметрами типа int, а не двумя параметрами типа double.

Но при переходе ко второму аргументу оказывается, что версия функции f() с двумя параметрами типа double точно соответствует аргументу 2.56. Вызов версии функции f() с двумя параметрами типа int потребует преобразования аргумента 2.56 из типа double в тип int. Таким образом, при рассмотрении только второго параметра версия f(double, double) функции f() имеет лучшее соответствие.

Компилятор отклонит этот вызов, поскольку он неоднозначен: каждая подходящая функция является лучшим соответствием по одному из аргументов. Было бы заманчиво обеспечить соответствие за счет явного приведения типов (см. раздел 4.11.3) одного из аргументов. Но в хорошо спроектированных системах в приведении аргументов не должно быть необходимости.

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

Упражнения раздела 6.6

Упражнение 6.49. Что такое функция-кандидат? Что такое подходящая функция?

Упражнение 6.50. С учетом приведенных в начале раздела объявлений функции f() перечислите подходящие функции для каждого из следующих вызовов. Укажите наилучше соответствие, или если его нет, то из-за отсутствия соответствия или неоднозначности вызова?

(a) f(2.56, 42) (b) f(42) (с) f(42, 0) (d) f(2.56, 3.14)

Упражнение 6.51. Напишите все четыре версии функции f(). Каждая из них должна выводить собственное сообщение. Проверьте свои ответы на предыдущее упражнение. Если ответы были неправильными, перечитайте этот раздел и выясните, почему вы ошиблись.

 

6.6.1. Преобразование типов аргументов

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

1. Точное соответствие. Типы аргумента и параметра совпадают в случае, если:

 • типы аргумента и параметра идентичны;

 • аргумент преобразуется из типа массива или функции в соответствующий тип указателя. (Указатели на функции рассматриваются в разделе 6.7);

 • аргумент отличается наличием или отсутствием спецификатора const верхнего уровня.

2. Соответствие в результате преобразования констант (см. раздел 4.11.2).

3. Соответствие в результате преобразования (см. раздел 4.11.1).

4. Соответствие в результате арифметического преобразования (см. раздел 4.11.1) или преобразования указателя (см. раздел 4.11.2).

5. Соответствие в результате преобразования класса (раздел 14.9).

#magnify.png Соответствие, требующее приведения и (или) целочисленного преобразования

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

При анализе вызова следует помнить, что малые целочисленные типы всегда преобразуются в тип int или больший целочисленный тип. Рассмотрим две функции, одна из которых получает тип int, а вторая тип short, версия short будет вызвана только со значениями типа short. Даже при том, что меньшие целочисленные значения могли бы быть ближе к соответствию, эти значения преобразуются в тип int, тогда как вызов версии short потребовал бы преобразования:

void ff(int);

void ff(short);

ff('a'); // тип char приводится к int, поэтому применяется f(int)

Все целочисленные преобразования считаются эквивалентными друг другу. Преобразование из типа int в unsigned int, например, не имеет преимущества перед преобразованием типа int в double. Рассмотрим конкретный пример.

void manip(long);

void manip(float);

manip(3.14); // ошибка: неоднозначный вызов

Литерал 3.14 имеет тип double. Этот тип может быть преобразован или в тип long, или в тип float. Поскольку возможны два целочисленных преобразования, вызов неоднозначен.

Соответствие функций и константные аргументы

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

Record lookup(Account&);       // функция, получающая ссылку на Account

Record lookup(const Account&); // новая функция, получающая ссылку на

                               // константу

const Account а;

Account b;

lookup(а); // вызов lookup(const Account&)

lookup(b); // вызов lookup(Account&)

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

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

Параметры в виде указателя работают подобным образом. Если две функции отличаются только тем, указывает ли параметр на константу или не константу, компилятор на основании константности аргумента вполне может решить, какую версию функции использовать: если аргумент является указателем на константу, то вызов будет соответствовать версии, получающей тип const*; в противном случае, если аргумент — указатель на не константу, вызывается версия, получающая простой указатель.

Упражнения раздела 6.6.1

Упражнение 6.52. Предположим, что существуют следующие объявления:

void manip(int, int);

double dobj;

Каков порядок (см. раздел 6.6.1) преобразований в каждом из следующих обращений?

(a) manip('a', 'z'); (b) manip(55.4, dobj);

Упражнение 6.53. Объясните назначение второго объявления в каждом из следующих наборов. Укажите, какие из них (если они есть) недопустимы.

(a) int calc(int&, int&);

    int calc(const int&, const int&);

(b) int calc(char*, char*);

    int calc(const char*, const char*);

(c) int calc(char*, char*);

    int calc(char* const, char* const);

 

Класс Sales_item, использованный в главе 1, является абстрактным типом данных. При использовании объекта класса Sales_item задействовался его интерфейс (т.е. операции, описанные в разделе 1.5.1). Мы не имели доступа к переменным-членам, хранящимся в объекте класса Sales_item. На самом деле нам даже не было известно, какие переменные-члены имеет этот класс.

Наш класс Sales_data (см. раздел 2.6.1) не был абстрактным типом данных. Он позволяет пользователям обращаться к его переменным-членам и вынуждает пользователей писать собственные операции. Чтобы сделать класс Sales_data абстрактным типом, необходимо определить операции, доступные для его пользователей. Как только класс Sales_data определит собственные операции, мы сможем инкапсулировать (т.е. скрыть) его переменные-члены.

 

7.1.1. Разработка класса

Sales_data

В конечном счете хочется, чтобы класс Sales_data поддержал тот же набор операций, что и класс Sales_item. У класса Sales_item была одна функция-член (member function) (см. раздел 1.5.2) по имени isbn, а также поддерживались операторы +, =, +=, << и >>.

Определение собственных операторов рассматривается в главе 14, а пока определим обычные (именованные) функции для этих операций. По причинам, рассматриваемым в разделе 7.1.5, функции, осуществляющие сложение и операции ввода-вывода, не будут членами класса Sales_data. Мы определим эти функции как обычные. Функция, выполняющая составное присвоение, будет членом класса, и по причинам, рассматриваемым в разделе 7.1.5, наш класс не должен определять присвоение.

Таким образом, интерфейс класса Sales_data состоит из следующих операций.

• Функция-член isbn(), возвращающая ISBN объекта.

• Функция-член combine(), добавляющая один объект класса Sales_data к другому.

• Функция add(), суммирующая два объекта класса Sales_data.

• Функция read(), считывающая данные из потока istream в объект класса Sales_data.

• Функция print(), выводящая значение объекта класса Sales_data в поток ostream.

Ключевая концепция. Различие в ролях программистов

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

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

#sheet.jpg Говоря о пользователях , программисты С++, как правило, имеют в виду как пользователей приложения, так и пользователей класса.

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

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

Использование пересмотренного класса Sales_data

Прежде чем думать о реализации нашего класса, обдумаем то, как можно использовать функции его интерфейса. В качестве примера использования этих функций напишем новую версию программы книжного магазина из раздела 1.6, работающую с объектами класса Sales_data, а не Sales_item:

Sales_data total;       // переменная для хранения текущей суммы

if (read(cin, total)) { // прочитать первую транзакцию

 Sales_data trans;      // переменная для хранения данных следующей

                        // транзакции

 while(read(cin, trans)) { // читать остальные транзакции

  if (total.isbn() == trans.isbn()) // проверить isbn

   total.combine(trans); // обновить текущую сумму

  else {

   print(cout, total) << endl; // отобразить результаты

   total = trans; // обработать следующую книгу

  }

 }

 print(cout, total) << endl;  // отобразить последнюю транзакцию

} else {                      // ввода нет

 cerr << "No data?!" << endl; // уведомить пользователя

}

Сначала определяется объект класса Sales_data для хранения текущей суммы. В условии оператора if происходит вызов функции read() для чтения в переменную total первой транзакции. Это условие работает, как и другие написанные ранее циклы с использованием оператора >>. Как и оператор >>, наша функция read() будет возвращать свой потоковый параметр, который и проверяет условие (см. раздел 4.11.2). Если функция read() потерпит неудачу, сработает часть else, выводящая сообщение об ошибке.

Если данные прочитаны успешно, определяем переменную trans для хранения всех транзакций. Условие цикла while также проверяет поток, возвращенный функцией read(). Пока операции ввода в функции read() успешны, условие выполняется и обрабатывается следующая транзакция.

В цикле while происходит вызов функции-члена isbn() объектов total и trans, возвращающей их ISBN. Если объекты total и trans относятся к той же книге, происходит вызов функции combine(), добавляющей компоненты объекта trans к текущей сумме, хранящейся в объекте total. Если объект trans представляет новую книгу, происходит вызов функции print(), выводящей итог по предыдущей книге. Поскольку функция print() возвращает ссылку на свой потоковый параметр, ее результат можно использовать как левый операнд оператора <<. Это сделано для того, чтобы вывести символ новой строки после результата, созданного функцией print(). Затем объект trans присваивается объекту total, начиная таким образом обработку записи следующей книги в файле.

По исчерпании ввода следует не забыть вывести данные последней транзакции. Для этого после цикла while используется еще один вызов функции print().

Упражнения раздела 7.1.1

Упражнение 7.1. Напишите версию программы обработки транзакций из раздела 1.6 с использованием класса Sales_data, созданного для упражнений в разделе 2.6.1.

 

7.1.2. Определение пересмотренного класса

Sales_data

У пересмотренного класса будут те же переменные-члены, что и у версии, определенной в разделе 2.6.1: член типа string по имени bookNo, представляющий ISBN, член типа unsigned по имени units_sold, представляющий количество проданных экземпляров книги, и член типа double по имени revenue, представляющий общий доход от этих продаж.

Как уже упоминалось, у класса будут также две функции-члена, combine() и isbn(). Кроме того, предоставим классу Sales_data другую функцию-член, чтобы возвращать среднюю цену, по которой были проданы книги. Эта функция, назовем ее avg_price(), не предназначена для общего использования. Она будет частью реализации, а не интерфейса.

Функции-члены определяют (см. раздел 6.1) и объявляют (см. раздел 6.1.2) как обычные функции. Функции-члены должны быть объявлены в классе, но определены они могут быть непосредственно в классе или вне тела класса. Функции, не являющиеся членами класса, но являющиеся частью интерфейса, как функции add(), read() и print(), объявляются и определяются вне класса.

С учетом вышеизложенного напишем пересмотренную версию класса Sales_data:

struct Sales_data {

 // новые члены: операции с объектами класса Sales_data

 std::string isbn() const { return bookNo; }

 Sales_data& combine(const Sales_data&);

 double avg_price() const;

 // те же переменные-члены, что и в p. 2.6.1

 std::string bookNo;

 unsigned units_sold = 0;

 double revenue = 0.0;

};

// функции интерфейса класса Sales_data, не являющиеся его членами

Sales_data add(const Sales_data&, const Sales_data&);

std::ostream &print(std::ostream&, const Sales_data&);

std::istream &read(std::istream&, Sales_data&);

Функции, определенные в классе, неявно являются встраиваемыми (см. раздел 6.5.2).

Определение функций-членов

Хотя каждый член класса должен быть объявлен в самом классе, тело функции-члена можно определить либо в, либо вне тела класса. Функция isbn() определяется в классе Sales_data, а функции combine() и avg_price() вне его.

Сначала рассмотрим функцию isbn(), возвращающую строку и имеющую пустой список параметров:

std::string isbn() const { return bookNo; }

Как и у любой функции, тело функции-члена является блоком. В данном случае блок содержит один оператор return, возвращающий значение переменной-члена bookNo объекта класса Sales_data. Интересно, как эта функция получает объект, член bookNo которого следует выбрать?

Указатель this

Давайте снова рассмотрим вызов функции-члена isbn():

total.isbn()

Здесь для вызова функции-члена isbn() объекта total используется точечный оператор (см. раздел 4.6).

За одним исключением, рассматриваемым в разделе 7.6, вызов функции-члена осуществляется от имени объекта. Когда функция isbn() обращается к члену класса Sales_data (например, bookNo), она неявно обращается к членам того объекта, из которого была вызвана. В этом вызове функции isbn(), когда она возвращает значение члена bookNo, речь идет о члене total.bookNo.

Функция-член способна обратиться к тому объекту, из которого она была вызвана, благодаря дополнительному неявному параметру this. Когда происходит вызов функции-члена, указатель this инициализируется адресом объекта, из которого была вызвана функция. Рассмотрим следующий вызов:

total.isbn()

Здесь компилятор присваивает адрес объекта total указателю this и неявно передает его как параметр функции isbn(). Компилятор как бы переписывает этот вызов так:

// псевдокод, в который преобразуется вызов функции-члена

Sales_data::isbn(&total)

Этот код вызывает функцию-член isbn() класса Sales_data, передав адрес объекта total.

В функции-члене можно обратиться непосредственно к членам объекта, из которого она была вызвана. Для использования членов объекта, на который указывает указатель this, можно не использовать оператор доступа к члену. Любое непосредственное использование члена класса подразумевает использование указателя this. Таким образом, когда функция isbn() использует переменную bookNo, она неявно использует член объекта, на который указывает указатель this. Это аналогично синтаксису this->bookNo.

Параметр this определяется неявно и автоматически. Кроме того, определить параметр или переменную по имени this самому нельзя, но в теле функции-члена его использовать можно. Вполне допустимо, хоть и не нужно, определить функцию isbn() так:

std::string isbn() const { return this->bookNo; }

Поскольку указатель this всегда предназначен для обращения к "этому" объекту, он является константным (см. раздел 2.4.2). Нельзя изменить адрес, хранящийся в указателе this.

Константные функции-члены

Еще одним важным моментом функции-члена isbn() является ключевое слово const, расположенное за списком параметров. Оно применяется для модификации типа неявного указателя this.

По умолчанию указатель this имеет тип константного указателя на неконстантную версию типа класса. Например, типом по умолчанию указателя this в функции-члене Sales_data является Sales_data *const. Хоть указатель this и неявен, он подчиняется обычным правилам инициализации, согласно которым (по умолчанию) нельзя связать указатель this с константным объектом (см. раздел 2.4.2). Следствием этого факта, в свою очередь, является невозможность вызвать обычную функцию-член для константного объекта.

Если бы функция isbn() была обычной и если бы указатель this был обычным параметром типа указателя, то мы объявили бы его как const Sales_data *const. В конце концов, тело функции isbn() не изменяет объект, на который указывает указатель this; таким образом, эта функция стала бы гибче, если бы указатель this был указателем на константу (см. раздел 6.2.3).

Однако указатель this неявный и не присутствует в списке параметров, поэтому нет места, где можно было бы указать, что он должен быть указателем на константу. Язык решает эту проблему, позволяя разместить ключевое слово const после списка параметров функции-члена. Это означает, что указатель this является указателем на константу. Функции-члены, использующие ключевое слово const таким образом, являются константными функциями-членами (const member function).

Тело функции isbn() можно считать написанным так:

// псевдокод, иллюстрирующий использование неявного указателя

// этот код недопустим: нельзя самому явно определить этот указатель

// обратите внимание, что это указатель на константу, поскольку isbn()

// является константным членом класса

std::string Sales_data::isbn(const Sales_data *const this)

{ return this->isbn; }

Тот факт, что this является указателем на константу, означает, что константные функции-члены не могут изменить объект, для которого они вызваны. Таким образом, функция isbn() может читать значения переменных- членов объектов, для которых она вызывается, но не изменять их.

Константные объекты, ссылки и указатели на константные объекты могут вызывать только константные функции-члены

Область видимости класса и функции-члены

Помните, что класс сам является областью видимости (см. раздел 2.6.1). Определения функций-членов класса находятся в области видимости самого класса. Следовательно, использованное функцией isbn() имя bookNo относится к переменной-члену, определенной в классе Sales_data.

Следует заметить, что функция isbn() может использовать имя bookNo, несмотря на то, что оно определено после функции isbn(). Как будет описано в разделе 7.4.1, компилятор обрабатывает классы в два этапа — сначала объявления членов класса, затем тела функций-членов, если таковые вообще имеются. Таким образом, тела функций-членов могут использовать другие члены своих классов, независимо от того, где именно в классе они определены.

Определение функции-члена вне класса

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

double Sales_data::avg_price() const {

 if (units_sold)

  return revenue/units_sold;

 else

  return 0;

}

Имя функции, Sales data::avg_price(), использует оператор области видимости (см. раздел 1.2), чтобы указать, что определяемая функция по имени avg_price объявлена в пределах класса Sales_data. Как только компилятор увидит имя функции, остальная часть кода интерпретируется как относящаяся к области видимости класса. Таким образом, когда функция avg_price() обращается к переменным revenue и units_sold, она неявно имеет в виду члены класса Sales_data.

Определение функции, возвращающей указатель this на объект

Функция combine() должна действовать как составной оператор присвоения +=. Объект, для которого вызвана эта функция, представляет собой левый операнд присвоения. Правый операнд передается как аргумент явно:

Sales_data& Sales_data::combine(const Sales_data &rhs) {

 units_sold += rhs.units_sold; // добавить члены объекта rhs

 revenue += rhs.revenue;       // к членам объекта 'this'

 return *this; // возвратить объект, для которого вызвана функция

}

Когда наша программа обработки транзакций осуществляет вызов

total.combine(trans); // обновить текущую сумму

адрес объекта total находится в неявном параметре this, а объект trans связан с параметром rhs. Таким образом, при вызове функции combine() выполняется следующий оператор:

units_sold += rhs.units_sold; // добавить члены объекта rhs

В результате произойдет сложение переменных total.units_sold и trans.units_sold, а сумма должна сохраниться снова в переменной total.units_sold.

Самым интересным в этой функции является тип возвращаемого значения и оператор return. Обычно при определении функции, работающей как стандартный оператор, она должна подражать поведению этого оператора. Стандартные операторы присвоения возвращают свой левый операнд как l-значение (см. раздел 144). Чтобы возвратить l-значение, наша функция combine() должна возвратить ссылку (см. раздел 6.3.2). Поскольку левый операнд — объект класса Sales_data, тип возвращаемого значения — Sales_data&.

Как уже упоминалось, для доступа к члену объекта, функция-член которого выполняется, необязательно использовать неявный указатель this. Однако для доступа к объекту в целом указатель this действительно нужен:

return *this; // возвратить объект, для которого вызвана функция

Здесь оператор return обращается к значению указателя this, чтобы получить объект, функция которого выполняется. Таким образом, для этого вызова возвращается ссылка на объект total.

Упражнения раздела 7.1.2

Упражнение 7.2. Добавьте функции-члены combine() и isbn() в класс Sales_data, который был написан для упражнений из раздела 2.6.2.

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

Упражнение 7.4. Напишите класс по имени Person, представляющий имя и адрес человека. Используйте для содержания каждого из этих членов тип string. В последующих упражнениях в этот класс будут добавлены новые средства.

Упражнение 7.5. Снабдите класс Person операциями возвращения имени и адреса. Должны ли эти функции быть константами? Объясните свой выбор.

 

7.1.3. Определение функций, не являющихся членом класса, но связанных с ним

Авторы классов нередко определяют такие вспомогательные функции, как наши функции add(), read() и print(). Хотя определяемые ими операции концептуально являются частью интерфейса класса, частью самого класса они не являются.

Мы определяем функции, не являющиеся членом класса, как любую другую функцию, т.е. ее объявление обычно отделено от определения (см. раздел 6.1.2). Функции, концептуально являющиеся частью класса, но не определенные в нем, как правило, объявляются (но не определяются) в том же заголовке, что и сам класс. Таким образом, чтобы использовать любую часть интерфейса, пользователю достаточно включить только один файл.

Обычно функция, не являющаяся членом класса, но из состава его интерфейса объявляется в том же заголовке, что и сам класс.

Определение функций read() и print()

Функции read() и print() выполняют ту же задачу, что и код в разделе 2.6.2, поэтому и не удивительно, что тела этих функций очень похожи на код, представленный там:

// введенные транзакции содержат ISBN, количество проданных книг и

// цену книги

istream &read(istream &is, Sales_data &item) {

 double price = 0;

 is >> item.bookNo >> item.units_sold >> price;

 item.revenue = price * item.units_sold;

 return is;

}

ostream &print(ostream &os, const Sales_data &item) {

 os << item.isbn() << " " << item.units_sold << " "

    << item.revenue << " " << item.avg_price();

 return os;

}

Функция read() читает данные из предоставленного потока в заданный объект. Функция print() выводит содержимое предоставленного объекта в заданный поток.

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

Второй заслуживающий внимания момент: функция print() не выводит новую строку. Обычно функции вывода осуществляют минимальное форматирование. Таким образом, пользовательский код может сам решить, нужна ли новая строка.

Определение функции add()

Функция add() получает два объекта класса Sales_data и возвращает новый объект класса Sales_data, представляющий их сумму:

Sales_data add(const Sales_data &lhs, const Sales_data &rhs) {

 Sales_data sum = lhs; // копирование переменных-членов из lhs в sum

 sum.combine(rhs);     // добавить переменные-члены rhs в sum

 return sum;

}

В теле функции определяется новый объект класса Sales_data по имени sum, предназначенный для хранения суммы двух транзакций. Инициализируем объект sum копией объекта lhs. По умолчанию копирование объекта класса подразумевает копирование и членов этого объекта. После копирования у членов bookNo, units_sold и revenue объекта sum будут те же значения, что и у таковых объекта lhs. Затем происходит вызов функции combine(), суммирующей значения переменных-членов units_sold и revenue объектов rhs и sum в последний. По завершении возвращается копия объекта sum.

Упражнения раздела 7.1.3

Упражнение 7.6. Определите собственные версии функций add(), read() и print().

Упражнение 7.7. Перепишите программу обработки транзакций, написанной для упражнений в разделе 7.1.2, так, чтобы использовать эти новые функции.

Упражнение 7.8. Почему функция read() определяет свой параметр типа Sales_data как простую ссылку, а функция print() — как ссылку на константу?

Упражнение 7.9. Добавьте в код, написанный для упражнений в разделе 7.1.2, операции чтения и вывода объектов класса Person.

Упражнение 7.10. Что делает условие в следующем операторе if?

if (read(read(cin, data1), data2))