Каждая программа С++ содержит одну или несколько

функций

(function), причем одна из них обязательно имеет имя

main()

. Запуская программу С++, операционная система вызывает именно функцию

main()

. Вот простая версия функции

main()

, которая не делает ничего, кроме возвращения значения 0 операционной системе:

int main() {

 return 0;

}

Определение функции содержит четыре элемента:

тип возвращаемого значения

(return type),

имя функции

(function name),

список параметров

(parameter list), который может быть пустым, и

тело функции

(function body). Хотя функция

main()

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

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

Большинство PC-ориентированных компиляторов обладают

интегрированной средой разработки

(Integrated Development Environment — IDE), которая объединяет компилятор с соответствующими средствами редактирования и отладки кода. Эти средства весьма удобны при разработке сложных программ, однако ими следует научиться пользоваться. Описание подобных систем выходит за рамки этой книги.

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

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

файлами исходного кода

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

.cc

,

.cxx

,

.cpp

, .

cp

и

.С

.

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

Оператор

while

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

while

, можно написать следующую программу, суммирующую числа от

1

до

10

включительно:

#include <iostream>

int main() {

 int sum = 0, val = 1;

 // продолжать выполнение цикла, пока значение val

В рассмотренном ранее цикле

while

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

val

. Мы проверяли ее значение в условии, а затем в теле цикла

while

увеличивали его.

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

оператор

for

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

for

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

#include <iostream>

int main() {

 int sum = 0;

В приведенных выше разделах мы писали программы, которые суммировали числа от 1 до 10. Логическое усовершенствование этой программы подразумевало бы запрос суммируемых чисел у пользователя. В таком случае мы не будем знать, сколько чисел суммировать. Поэтому продолжим читать числа, пока будет что читать.

#include <iostream>

int main() {

 int sum = 0, value = 0;

 // читать данные до конца файла, вычислить сумму всех значений

Подобно большинству языков, С++ предоставляет

оператор

if

, который обеспечивает выполнение операторов по условию. Оператор

if

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

#include <iostream>

int main() {

 // currVal - подсчитываемое число; новые значения будем читать в val

 int currVal = 0, val = 0;

В языке С++ определен набор базовых типов, включая

арифметические типы

(arithmetic type), и специальный тип

void

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

void

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

Есть две разновидности арифметических типов:

целочисленные типы

(включая символьные и логические типы) и

типы с плавающей запятой

.

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

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

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

преобразовать

(convert) объект данного типа в другой, связанный тип.

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

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

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

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

Такое значение, как

42

, в коде программы называется

литералом

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

Целочисленный литерал может быть в десятичной, восьмеричной или шестнадцатеричной форме. Целочисленные литералы, начинающиеся с нуля (

0

), интерпретируются как восьмеричные, а начинающиеся с

0x

или

0X

— как шестнадцатеричные. Например, значение

20

можно записать любым из трех следующих способов.

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

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

Переменная

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

Простое определение переменной состоит из

спецификатора типа

(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 — библиотечный тип, представляющий последовательность

Для обеспечения возможности разделить программу на несколько логических частей язык С++ предоставляет технологию, известную как

раздельная компиляция

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

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

std::cout

и

std::cin

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

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

Для поддержки раздельной компиляции язык С++ различает объявления и определения.

Объявление

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

Определение

(definition) создает соответствующую сущность.

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

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

int somename, someName, SomeName, SOMENAME;

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

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

Область видимости

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

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

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

#include <iostream>

Составной тип

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

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

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

&d

, где

d

— объявляемое имя:

int ival = 1024;

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

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

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

связывание

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

следует

инициализировать.

Указатель

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

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

Тип указателя определяется оператором в форме

*d

, где

d

— определяемое имя. Символ

*

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

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

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

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

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

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

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

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

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

спецификатор

const

(qualifier const):

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

Это определит переменную

bufSize

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

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

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

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

ссылка на константу

(reference to

const

), т.е. ссылка на объект типа

const

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

const int ci = 1024;

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

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

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

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

указатель на константу

(pointer to

const

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

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

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

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

                          //  const double

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

спецификатор const верхнего уровня

(top-level

const

) используется для обозначения того ключевого слова

const

, которое объявляет константой сам указатель. Когда указатель способен указывать на константный объект, это называется

спецификатор const нижнего уровня

(low-level

const

). 

В более общем смысле спецификатор

const

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

const

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

const

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

const

как верхнего, так и нижнего уровня, независимо друг от друга.

int i = 0;

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

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

Константное выражение

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

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

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

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

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

Строка

(string) — это последовательность символов переменной длины. Чтобы использовать тип

string

, необходимо включить в код заголовок

string

. Поскольку тип

string

принадлежит библиотеке, он определен в пространстве имен

std

. Наши примеры подразумевают наличие следующего кода:

#include <string>

using std::string;

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

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

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

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

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

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

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

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

isbn()

класса

Sales_item

(см. раздел 1.5.2). Класс также может определить то, что означают различные символы операторов, такие как

<<

или

+

, когда они применяются к объектам класса. Наиболее распространенные операции класса

string

приведены в табл. 3.2.

Таблица 3.2. Операции класса string

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

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

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

cctype

.

Таблица 3.3. Функции cctype

Вектор

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

контейнер

(container), поскольку он "содержит" другие объекты. Более подробная информация о контейнерах приведена в части II.

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

using

.

#include <vector>

using std::vector;

Тип

vector

— это

шаблон класса

(class template). Язык С++ поддерживают шаблоны и классов, и функций. Написание шаблона требует довольно глубокого понимания языка С++. До главы 16 мы даже не будем рассматривать создание собственных шаблонов! К счастью, чтобы использовать шаблоны, вовсе не обязательно уметь их создавать.

Подобно любому типу класса, шаблон

vector

контролирует способ определения и инициализации векторов. Наиболее распространенные способы определения векторов приведены в табл. 3.4.

Инициализация вектора по умолчанию (см. раздел 2.2.1) позволяет создать пустой вектор определенного типа:

vector<string> svec; // инициализация по умолчанию;

                     //  у svec нет элементов

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

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

Если необходим вектор со значениями от 0 до 9, то можно легко использовать списочную инициализацию. Но что если необходимы элементы от 0 до 99 или от 0 до 999? Списочная инициализация была бы слишком громоздкой. В таких случаях лучше создать пустой вектор и использовать его функцию-член

push_back()

, чтобы добавить элементы во время выполнения. Функция

push_back()

вставляет переданное ей значение в вектор как новый последний элемент. Рассмотрим пример.

vector<int> v2; // пустой вектор

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

 v2.push_back(i); // добавить последовательность целых чисел в v2

Кроме функции

push_back()

, шаблон

vector

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

string

. Наиболее важные из них приведены в табл. 3.5.

Таблица 3.5. Операции с векторами

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

for

(раздел 3.2.3).

Хотя для доступа к символам строки или элементам вектора можно использовать индексирование, для этого существует и более общий механизм —

итераторы

(iterator). Как будет продемонстрировано в части II, кроме векторов библиотека предоставляет несколько других видов контейнеров. У всех библиотечных контейнеров есть итераторы, но только некоторые из них поддерживают оператор индексирования. С технической точки зрения тип

string

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

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

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

begin()

и

end()

. Функция-член

begin()

возвращает итератор, который обозначает первый элемент (или первый символ), если он есть.

// типы b и е определяют компилятор; см. раздел 2.5.2

// b обозначает первый элемент контейнера v, а е - элемент

// после последнего

auto b = v.begin(), е = v.end();

Инкремент итератора перемещает его на один элемент. Инкремент поддерживают итераторы всех библиотечных контейнеров. Аналогично операторы

==

и

!=

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

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

арифметическими действиями с итераторами

(iterator arithmetic). Они приведены в табл. 3.7.

Таблица 3.7. Операции с итераторами векторов и строк

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

Существуют

унарные операторы

(unary operator) и

парные операторы

(binary operator). Унарные операторы, такие как обращение к адресу (

&

) и обращение к значению (

*

), воздействуют на один операнд. Парные операторы, такие как равенство (

==

) и умножение (

*

), воздействуют на два операнда. Существует также (всего один)

тройственный оператор

(ternary operator), который использует три операнда, а также

оператор вызова функции

(function call), который получает неограниченное количество операндов.

Некоторые

символы

(symbol), например

*

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

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

приоритета

(precedence),

порядка

(associativity) и

порядка вычисления

(order of evaluation) операторов. Например, в следующем выражении используются сложение, умножение и деление:

5 + 10 * 20/2;

Выражения с двумя или несколькими операторами называются составными (compound expression). Результат составного выражения определяет способ группировки операндов в отдельных операторах. Группировку операндов определяют приоритет и порядок. Таким образом, они определяют, какие части выражения будут операндами для каждого из операторов в выражении. При помощи скобок программисты могут изменять эти правила, обеспечивая необходимую группировку.

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

• Благодаря приоритету результатом выражения

3 + 4*5

будет

23

, а не

35

.

• Благодаря порядку результатом выражения

20-15-3

будет

2

, а не

8

.

В более сложном примере при вычислении слева направо следующего выражения получается 20:

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

f1()

и

f2()

будут вызваны перед умножением:

int i = f1() * f2();

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

f1()

вызвана до функции

f2()

, или наоборот.

Для операторов, которые не определяют порядок вычисления, выражение, пытающееся

обратиться

к тому же объекту и

изменить его

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

<<

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

int i = 0;

Язык С++ предоставляет два оператора, обеспечивающих условное выполнение. Оператор

if

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

switch

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

Оператор

if

выполняет один из двух операторов в зависимости от истинности своего условия. Существуют две формы оператора

if

: с разделом

else

и без него. Синтаксис простой формы оператора

if

имеет следующий вид:

if ( условие )

 оператор

Оператор

if else

имеет следующую форму:

if ( условие )

Оператор

switch

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

• Читать каждый введенный символ.

• Сравнить каждый символ с набором искомых гласных.

• Если символ соответствует одной из гласных букв, добавить

1

к соответствующему счетчику.

• Отобразить результаты.

Итерационные операторы

(iterative statement), называемые также

циклами

(loop), обеспечивают повторное выполнение кода, пока их условие истинно. Операторы

while

и

for

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

do while

сначала выполняет тело, а затем проверяет свое условие.

Оператор

while

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

while ( условие )

  оператор

Пока

условие

истинно (значение

true

),

оператор

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

false

), оператор не выполняется.

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

Оператор

for

имеет следующий синтаксис:

for ( инициализирующий-оператор условие ; выражение )

  оператор

Слово

for

и часть в круглых скобках зачастую упоминают как

заголовок

for

(

for

header).

Инициализирующий-оператор

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

Новый стандарт ввел упрощенный оператор

for

, который перебирает элементы контейнера или другой последовательности. Синтаксис

серийного оператора

for

(range

for

) таков:

for ( объявление : выражение )

  оператор

выражение

должно представить некую последовательность, такую, как список инициализации (см. раздел 3.3.1), массив (см. раздел 3.5), или объект такого типа, как

vector

или

string

, у которого есть функции-члены

begin()

и

end()

, возвращающие итераторы (см. раздел 3.4).

объявление

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

auto

(см. раздел 2.5.2). Так компилятор выведет тип сам. Если необходима запись в элементы последовательности, то переменная цикла должна иметь ссылочный тип.

Оператор

do while

похож на оператор

while

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

do

  оператор

while (условие);

После заключенного в скобки условия оператор

do while

заканчивается точкой с запятой.