Создание программы
Все вы использовали компьютерные программы, такие как текстовый процессор, электронные таблицы и даже Microsoft Windows. Компьютерные программы, или программное обеспечение, представляют собой файлы, содержащие инструкции, которые указывают компьютеру, что следует делать. Если вы работаете в среде Windows, то, например, файлы с расширениями ЕХЕ и СОМ содержат команды, которые компьютер может выполнять. Другими словами, файлы содержат специальные инструкции, выполняемые компьютером, обычно одну за другой, для решения определенной задачи. При создании программы вы указываете инструкции, которые компьютер должен выполнить.
Программирование представляет собой процесс определения последовательности инструкций, которые должен выполнить компьютер для решения определенной задачи. Для указания этих инструкций вы используете язык программирования, например C++. С помощью текстового редактора вы вносите программные операторы в исходный файл. Далее вы используете специальную программу — компилятор — для преобразования операторов из формата, который вы можете читать и понимать, в единицы и нули, которые понимает компьютер.
СОЗДАНИЕ ПРОСТОЙ ПРОГРАММЫ
#include <iostream.h>
void main(void)
{
cout << «Учимся программировать на языке C++!»;
}
КОМПИЛЯЦИЯ ВАШЕЙ ПРОГРАММЫ
Компьютер работает с комбинациями единиц и нулей (называемых машинным языком), которые представляют наличие или отсутствие электрических сигналов. Если сигнал равен единице (наличие), компьютер может выполнить одну операцию, а если сигнал равен нулю (отсутствие), компьютер может выполнить другую операцию. Однако к счастью, нет необходимости писать программы в нулях и единицах (как это делали программисты в 1940 и 50 гг.). Вместо этого специальная программа — компилятор C++ — преобразует операторы программы (ваш исходный код) в машинный язык.
Другими словами, компилятор просматривает исходный файл, содержащий операторы программы на C++. Если ваши операторы не нарушают ни одно правило языка C++, компилятор преобразует их в машинный язык (единицы и нули), который компьютер может выполнить. Компилятор хранит машинный язык в выполняемом файле, имеющем, как правило, расширение ЕХЕ.
СОЗДАНИЕ ВТОРОЙ ПРОГРАММЫ
#include <iostream.h>
void main(void)
{
cout << «Программировать на C++ просто!»;
}
ИЗУЧЕНИЕ СИНТАКСИЧЕСКИХ ОШИБОК
Каждый язык — английский, французский, немецкий и даже C++ — имеет набор правил, называемых синтаксисом, которым вы должны следовать, когда используете данный язык. В английском языке, например, предложения обычно заканчиваются точкой, восклицательным или вопросительным знаком. Вы также используете заглавные буквы в начале предложения. В синтаксисе C++ используется точка с запятой, круглые скобки, фигурные скобки и многие другие символы. Когда вы забываете или неправильно употребляете эти символы, компилятор C++ выводит на экран сообщение об ошибке, которое описывает ошибку и соответствующий ей номер строки в исходном файле.
Компилятор C++ не может создать выполнимую программу, пока не будут исправлены все синтаксические ошибки. #include <iostream.h>
ПРЕДСТАВЛЕНИЕ ОБ ОПЕРАТОРЕ #include
При компиляции программы оператор #include заставляет компилятор включить содержимое заданного файла в начало вашей программы. В данном случае компилятор включит содержимое файла iostream.h.
Файлы с расширением h, которые вы включаете в начало (или заголовок) вашей программы, называются заголовочными файлами. Каждый заголовочный файл содержит определения, предоставляемые компилятором для различных операций. Например, существует заголовочный файл, который содержит определения для математических операций, другой заголовочный файл описывает файловые операции и т. д.
Замечание: Никогда не изменяйте содержимое заголовочных файлов. Это может привести к ошибкам компиляции в каждой создаваемой вами программе.
ЧТО ТАКОЕ void main(void)
При создании программы на C++ ваш исходный файл будет содержать множество операторов. Как вы поймете в процессе изучения, порядок, в котором операторы появляются в программе, не обязательно должен совпадать с порядком, в котором операторы будут выполняться при запуске программы. Каждая программа на C++ имеет один вход, с которого начинается выполнение программы, — главную программу. В программах на C++ оператор void main(void) указывает стартовую точку вашей программы. Оператор void main(void) указывает начальные (или главные) операторы программы — часть программы, которая выполняется первой.
Использование void
Программы используют слово void для указания того, что функция не возвращает значения или не имеет значений, передаваемых в нее.
void main () //———-> Программа не возвращает значение
ИСПОЛЬЗОВАНИЕ cout ДЛЯ ОТОБРАЖЕНИЯ ВЫВОДА НА ЭКРАН
Чтобы вывести сообщение, программы использовали cout и двойной знак «меньше» (<<), как показано ниже:
cout << «Привет, C++!»;
Слово cout представляет собой выходной поток, который C++ назначает на стандартное устройство вывода операционной системы. По умолчанию операционная система назначает стандартное устройство вывода на экран дисплея. Чтобы вывести сообщение на экран, вы просто используете двойной символ «меньше» (называемый оператором вставки) с выходным потоком cout.
ВЫВОД НЕСКОЛЬКИХ ЗНАЧЕНИЙ ОДНОВРЕМЕННО
Как вы уже знаете, двойной знак «меньше» является операцией вставки (эта операция вставляет символы в выходной поток для отображения). С помощью cout вы можете использовать несколько операций вставки в пределах одного оператора.
#include <iostream.h>
void main(void)
(
cout << 1 << 0 << 0 << 1;
}
Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующее:
1001
ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ В ПРОГРАММАХ
Ваши программы используют переменные для хранения информации. В зависимости от типа хранимого значения, например, целое число, буква алфавита или число с плавающей точкой, тип вашей переменной будет разным.
Тип переменной указывает тип значения, хранимого в переменной, а также набор операций (таких как сложение, умножение и другие), которые программа может выполнять над значением переменной. Большинство программ на C++ будут использовать типы переменных, перечисленные в табл. 4.1.
Таблица 4.1. Типы переменных C++.
| Тип | Хранимые значения |
| char | Значения в диапазоне от -128 до 127. Обычно используется для хранения букв алфавита |
| int | Значения в диапазоне от -32768 до 32767 |
| unsigned | Значения в диапазоне от 0 до 65535 |
| long | Значения в диапазоне от -2147483648 до 2147483647 |
| float | Значения в диапазоне от -3.4 x 10-38 до 3.4 x 1038 |
| double | Значения в диапазоне от 1.7х 10-308 до 1.7х 10308 |
Прежде чем вы сможете использовать переменную, ваша программа должна ее объявить. Другими словами, вам следует представить переменную компилятору C++. Чтобы объявить переменную в программе, вам следует указать тип переменной и ее имя, по которому программа будет обращаться к данной переменной.
тип_переменной имя_переменной;
Фрагмент следующей программы объявляет три переменные, используя типы int, float и long:
#include <iostream.h>
void main()
{
int test_score;
float salary;
long distance_to_mars;
}
Важно обратить внимание, что данная программа ничего не выполняет, а только объявляет переменные. Как видите, объявление каждой переменной заканчивается точкой с запятой. Если вы объявляете несколько переменных одного и того же типа, можно разделять их имена запятой. Следующий оператор, например, объявляет три переменных с плавающей точкой:
float salary, income_tax, retirement_fund;
ПРИСВАИВАНИЕ ЗНАЧЕНИЯ ПЕРЕМЕННОЙ
Как вы уже знаете, переменные хранят значения во время выполнения программы. После объявления переменной вы используете оператор присваивания C++ (знак равно), чтобы присвоить значение переменной. Следующие операторы присваивают значения нескольким разным переменным. Обратите внимание на использование точки с запятой в конце каждого оператора:
age = 32;
salary = 25000.75;
distance_to_the_moon = 238857;
Присваивание значения при объявлении
При объявлении переменной часто удобно присваивать ей начальное значение. Чтобы упростить такую процедуру, C++ позволяет присваивать значение во время объявления переменной, как показано ниже:
int age = 32;
float salary = 25000.75;
long distance_to_the_moon = 238857;
Многие программы, представленные в этой книге, присваивают значения переменным при объявлении.
ИСПОЛЬЗОВАНИЕ ЗНАЧЕНИЯ ПЕРЕМЕННОЙ
После присвоения значения переменной ваши программы могут использовать это значение, просто обращаясь к ее имени. Следующая программа SHOWVARS.CPP присваивает значения трем переменным и затем выводит значение каждой переменной, используя cout:
#include <iostream.h>
void main ()
{
int age = 32,
float salary = 25000.75;
long distance_to_the_moon = 238857;
cout << «Служащему » << age << » года (лет)» << endl;
cout << «Оклад служащего составляет $» << salary << endl;
cout << «От земли до луны » << distance_to_the_moon << » миль» << endl;
}
Замечание: Последний оператор cout не помещается на одной строке. В этом случае программа просто переносит слова на следующую строку. Вы можете сделать такой перенос, поскольку C++ использует точку с запятой для указания конца оператора. Если вам необходимо перенести строку, постарайтесь не делать этого в середине символьной строки (внутри двойных кавычек), используйте дополнительный отступ для перенесенной части строки, как показано выше.
ИСПОЛЬЗОВАНИЕ КОММЕНТАРИЕВ ДЛЯ УЛУЧШЕНИЯ ЧТЕНИЯ ВАШИХ ПРОГРАММ
По мере усложнения ваших программ количество содержащихся в них операторов может сделать программы слишком трудными для понимания. Поскольку другим программистам может потребоваться понять и, возможно, изменить ваши программы, вам следует делать программы более удобочитаемыми. Способы улучшения удобочитаемости программ включают:
- Использование понятных по смыслу имен переменных, описывающих их применение.
- Использование подходящих отступов и выравнивания
- Использование пустых строк для разделения несвязанных операторов.
- Использование комментариев, которые объясняют работу программы.
При создании программ вы можете поместить в исходном файле замечания, которые объясняют работу программы. Такие замечания (называемые комментариями) не только помогают другим программистам понять вашу программу, но могут напомнить, почему программа содержит определенные операторы, если вы ее посмотрите через несколько месяцев. Для размещения комментария в своих программах на C++ просто поставьте два знака прямого слеша (//), как показано ниже:
// Это комментарий
Когда компилятор C++ встречает двойной слеш, он игнорирует весь оставшийся на этой строке текст. По крайней мере размещайте в начале каждой программы комментарии, которые указывают, кто написал программу, когда и почему:
// Программа: BUDGET.CPP
// Программист: Kris Jamsa
// дата создания: 1-10-96
//
// Цель: Ежемесячная информация о бюджете.
Комментарий справа от оператора присваивания обеспечивает дополнительную информацию всем, кто читает программу. У начинающих программистов часто возникают проблемы, связанные с тем, что и когда комментировать. Как правило, вы включаете немного комментариев в ваши программы. Поэтому убедитесь, что они полезны. Следующие комментарии не дают дополнительной информации программистам, читающим код:
аде =32; // Присвоить 32 переменной age
salary = 25000.75; // Присвоить 25000.75 переменной salary
Цель использования комментариев заключается в том, чтобы объяснить работу программы.
ОСНОВНЫЕ МАТЕМАТИЧЕСКИЕ ОПЕРАЦИИ
Таблица 5.1. Основные математические операции С++
| Операция | Назначение | Пример |
| + | Сложение | total = cost + tax; |
| - | Вычитание | change = payment – total; |
| *. | Умножение | tax = cost * tax_rate; |
| / | Деление | average = total / count; |
Следующая программа SHOWMATH.CPP использует cout для вывода реультата нескольких простых арифметических операций:
#include <iostream.h>
void main()
{
cout << «5 + 7 = » << 5 + 7 << endl;
cout << «12 – 7 = » << 12 – 7 << endl;
cout << «1.2345 * 2 = » << 1.23.45 * 2 << endl;
cout << «15 / 3 = » << 15 / 3 << endl;
}
Операция инкремента
Обычной операцией является прибавление 1 к значению целой переменной. Например, предположим, что ваша программа использует переменную с именем count, чтобы сохранить данные о количестве напечатанных файлов. Каждый раз, когда программа печатает файл, 1 будет добавляться к текущему значению count. Используя оператор присваивания C++, ваша программа может увеличивать значение count, как показано ниже:
count = count + 1;
В данном случае программа сначала выбирает значение count, а затем добавляет к нему единицу. Далее программа записывает результат сложения обратно в переменную count. Следующая программа INTCOUNT.CPP использует оператор присваивания для увеличения переменной count (которая первоначально содержит значение 1000) на единицу (присваивая переменной результат 1001):
#include <iostream.h>
void main()
{
int count = 1000;
cout << «начальное значение count равно» << count << endl;
count = count + 1;
cout << «конечное значение count равно» << count << endl;
}
Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
начальное значение count равно 1000
конечное значение count равно 1001
Так как увеличение значения переменной представляет собой обычную операцию в программах, в C++ есть операция инкремента (увеличения) — двойной знак плюс (++). Операция инкремента обеспечивает быстрый способ прибавления единицы к значению переменной. Следующие операторы, например, увеличивают значение переменной count на 1:
count = count + 1; count++;
Следующая программа INC_OP.CPP использует операцию инкремента для наращивания значения переменной count на 1:
#include <iostream.h>
void main()
{
int count = 1000;
cout << «начальное значение count равно » << count << endl;
count++;
cout << «конечное значение count равно » << count << endl;
}
Эта программа работает так же, как INCCOUNT.CPP, которая использовала оператор присваивания для увеличения значения переменной. Когда C++ встречает операцию инкремента, он сначала выбирает значение переменной, добавляет к этому значению единицу, а затем записывает результат обратно в переменную.
Представление о префиксной (до) и постфиксной (после) операциях инкремента
При использовании операций инкремента ваши программы могут размещать оператор инкремента до или после переменной, как показано ниже:
++variable; variable++;
Так как первый оператор появляется до переменной, он называется префиксным оператором инкремента. Аналогично этому, второй оператор появляется после переменной и называется постфиксным оператором инкремента. Вам необходимо знать, что C++ трактует эти два оператора по-разному. Например, рассмотрим следующий оператор присваивания:
current_count = count++;
Этот оператор присваивания указывает C++ присвоить текущее значение count переменной current_count. В дополнение к этому постфиксный оператор увеличения заставляет C++ увеличить текущее значение count. Использование постфиксного оператора в этом случае делает показанный выше оператор эквивалентным следующим двум операторам:
current_count = count;
count = count + 1;
Теперь рассмотрим следующий оператор присваивания, который использует префиксный оператор инкремента:
current_count = ++count;
В этом случае оператор присваивания указывает C++ сначала увеличить значение count, а затем присвоить результат переменной current_count. Использование префиксного оператора инкремента делает показанный выше оператор эквивалентным следующим двум операторам:
count = count + 1;
current_count = count;
Следующая программа PRE_POST.CPP иллюстрирует использование префиксной и постфиксной операций инкремента:
#include <iostream.h>
void main()
{
int small_count = 0;
int big_count = 1000;
cout << «small_count равно » << small_count << endl;
cout << «small_count++ производит » << small_count++ << endl;
cout << «конечное значение small_count равно » << sniall_count << endl;
cout << «big_count равно » << big_count << endl;
cout << «++big_count производит » << ++big_count << endl;
cout << «конечное значение big_count равно » << big_count << endl;
}
Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
small_count равно 0
small_count++ производит 0
конечное значение small_count равно 1
big_count равно 1000
++big_count производит 1001
конечное значение big_count равно 1001
С переменной small_count программа использует постфиксную операцию инкремента. В результате программа выводит текущее значение переменной (0), а затем увеличивает его на 1. С переменной big_count программа использует префиксную операцию инкремента. В результате программа сначала увеличивает значение переменной (1000 + 1), а затем выводит результат (1001).
С++ обеспечивает также операции декремента (уменьшения)
Как вы уже знаете, двойной знак плюс (++) представляет собой оператор инкремента C++. Подобным образом двойной знак минус (–) соответствует оператору декремента (уменьшения) C++, который уменьшает значение переменной на 1. Как и в случае с операцией инкремента, C++ поддерживает префиксный и постфиксный операторы декремента. Следующая программа DECCOUNT.CPP иллюстрирует использование оператора декремента C++:
#include <iostream.h>
void main()
{
int small_count = 0;
int big_count = 1000;
cout << «small_count равно » << small_count << endl;
cout << «small_count– производит » << small_count– << endl;
cout << «конечное значение small_count равно » “ small_count << endl;
cout << «big_count равно » << big_count << endl;
cout << «–big_count производит » << –big_count << endl;
cout << «конечное значение big_count равно » << big_count << endl;
}
Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
small_count равно 0
small_count– производит 0
конечное значение small_count равно -1
big_count равно 1000
—big_count производит 999
конечное значение big_count равно 999
Как видите, префиксный и постфиксный операторы декремента C++ работают так же, как и соответствующие операторы декремента, с той лишь разницей, что они уменьшают значение переменной на 1.
ДРУГИЕ ОПЕРАТОРЫ С++
В программах на C++ вы можете встретить одну или несколько операций, перечисленных в табл. 5.2:
Таблица 5.2. Операции C++, которые вы можете встретить в программах.
| Операция | Функция |
| % | Взятие по модулю или остаток; возвращает остаток целочисленного деления |
| ~ | Дополнение; инвертирует биты значений |
| & | Побитовое И |
| | | Побитовое включающее ИЛИ |
| ^ | Побитовое исключающее ИЛИ |
| << | Сдвиг влево; сдвигает биты значения влево на указанное количество разрядов |
| >> | Сдвиг вправо; сдвигает биты значения вправо на указанное количество разрядов |
СТАРШИНСТВО ОПЕРАЦИЙ
При выполнении арифметических операций в C++ необходимо знать, что C++ выполняет операции в определенном порядке, основанном на старшинстве операций. Например, операция умножения выполняется до сложения. Чтобы лучше понять старшинство операций, рассмотрите следующие выражения:
result =5+2*3;
В зависимости от порядка, в котором C++ выполняет умножение и сложение, результат будет разным:
result =5+2*3;
=7*3;
= 21;
result =5+2*3;
=5+6;
= 11;
Чтобы избежать путаницы, C++ присваивает каждой операции приоритет, который определяет порядок выполнения операций. Так как C++ выполняет операции в определенном порядке, то и ваши программы будут проводить арифметические вычисления соответствующим образом.
Таблица 5.3 перечисляет старшинство операций C++. Операции, находящиеся в верхней части, имеют более высокий приоритет. Операции внутри каждой части имеют одинаковый приоритет. Если вы рассмотрите таблицу, то увидите, что в C++ умножение имеет более высокий приоритет, чем сложение.
Таблица 5.3. Старшинство операций в C++.
| Операция | Имя | Пример |
| :: Разрешение области видимости classname::classmember_name | ||
| :: | Глобальное разрешение | ::variable_name |
| . | Выбор элемента | object.member_name |
| -> | Выбор элемента | pointer->membername |
| [] | Индексация | pointer[element] |
| () | Вызов функции | expression(parameters) |
| () | Построение значения | type(parameters) |
| sizeof | Размер объекта | sizeof expression |
| sizeof | Размер типа | sizeof(type) |
| ++ | Приращение после | variable++ |
| ++ | Приращение до | ++variable |
| – | Уменьшение после | variable– |
| – | Уменьшение до | – variable |
| & | Адрес объекта | &variable |
| * | Разыменование | *pointer |
| new | Создание (размещение) | new type |
| delete | Уничтожение (освобождение) delete pointer | |
| delete[] | Уничтожение массива | delete pointer |
| ~ | Дополнение | ~expression |
| ! | Логическое НЕ | ! expression |
| + | Унарный плюс | +1 |
| - | Унарный минус | -1 |
| () | Приведение | (type) expression |
| .* | Выбор элемента | object.*pointer |
| -> | Выбор элемента | object->*pointer |
| * | Умножение | expression * expression |
| / | Деление | expression / expression |
| % | Взятие по модулю | expression % expression |
| + | Сложение (плюс) | expression + expression |
| - | Вычитание (минус) | expression expression |
Управление порядком, в котором C++ выполняет операции
Как вы уже знаете, C++ назначает операциям различный приоритет, который и управляет порядком выполнения операций. К сожалению, иногда порядок, в котором C++ выполняет арифметические операции, не соответствует порядку, в котором вам необходимо их выполнить. Например, предположим, что вашей программе необходимо сложить две стоимости и затем умножить результат на налоговую ставку:
cost = price_a + price_b * 1.06;
К сожалению, в этом случае C++ сначала выполнит умножение (price_b * 1.06), а затем прибавит значение price_a.
Если ваши программы должны выполнять арифметические операции в определенном порядке, вы можете заключить выражение в круглые скобки. Когда C++ оценивает выражение, он сначала всегда выполняет операции, сгруппированные в круглых скобках. Например, рассмотрим следующее выражение:
result =(2+3)* (3+4);
C++ вычисляет данное выражение в следующем порядке:
result = (2 + 3) * (3 + 4);
= (5) * (3 + 4);
= 5 * (7);
=5*7;
= 35;
Подобным образом группируя выражения внутри круглых скобок, вы можете управлять порядком, в котором C++ выполняет арифметические операции. Аналогично предыдущему примеру, ваша программа может сложить две стоимости внутри круглых скобок, как показано ниже:
cost = (price_a + price_b) * 1.06;
ПЕРВОЕ ЗНАКОМСТВО С cin
Точно так же как выходной поток cout позволяет вашим программам записать вывод на экран, входной поток cin позволяет программам читать ввод с клавиатуры. Когда программы используют cin для чтения ввода с клавиатуры, они должны указать переменную, в которую cin поместит данные. Следующая программа FIRSTCIN.CPP использует cin для чтения числа, введенного с клавиатуры. Программа присваивает введенное число переменной с именем number, а затем выводит значение переменной, используя выходной поток cout:
#include <iostream.h>
void main()
{
int number; II Число, читаемое с клавиатуры
cout << «Введите ваше любимое число и нажмите Enter: «;
cin >> number;
cout << «Ваше любимое число равно » << number << endl;
}
Когда вы откомпилируете и запустите эту программу, на вашем экране появится сообщение, предлагающее вам ввести ваше любимое число. Если вы введете число и нажмете ENTER, программа присвоит ввод переменной number. Затем, используя cout, программа выведет сообщение, отображающее ваше любимое число.
Следующая программа TWONBRS.CPP запрашивает у вас два числа. Программа присваивает числа переменным first и second. Затем программа выводит числа, используя cout:
#include <iostream.h>
void main()
{
int first, second; // Числа, введенные с клавиатуры
cout << «Введите два числа и нажмите Enter: «;
cin >> first >> second;
cout << «Были введены числа » << first << » и » << second << endl;
}
Обратите внимание на использование с cin двух операторов извлечения:
cin >> first >> second;
В этом случае cin присвоит первое введенное значение переменной first, a второе переменной second. Если для вашей программы требуется третье значение, вы можете использовать третий оператор извлечения, как показано ниже:
cin >> first >> second >> third;
Если вы применяете cin для чтения чисел с клавиатуры, cin использует левый пустой символ (пробел, табуляцию, возврат каретки), чтобы определить, где начинается одно значение, а где второе. Экспериментируйте с программой TWONBRS, разделяя числа табуляцией, пробелом и возвратом каретки.
Чтение символьных данных
Обе предыдущие программы использовали cin для чтения целых чисел в переменные типа int. Следующая программа CIN_CHAR.CPP использует входной поток cin для чтения символов с клавиатуры. Как видите, программа читает символ в переменную типа char.
#include <iostream.h>
void main()
{
char letter;
cout << «Введите любой символ и нажмите Enter: «;
cin >> letter;
cout << «Был введен символ » << letter << endl;
}
СРАВНЕНИЕ ДВУХ ЗНАЧЕНИЙ
Когда ваши программы принимают решение, они обычно выполняют некоторый вид проверки. Например, одна программа может проверять, равны ли тестовые очки студента 100, а вторая программа — составляет ли стоимость покупки больше $50.00. Для выполнения подобных проверок ваши программы будут использовать операции сравнения C++, перечисленные в табл. 7.1. Операции сравнения позволяют проверять, каким образом одно значение соотносится с другим. Другими словами, используя операции сравнения, программы могут проверить, больше одно значение, меньше или равно другому.
Таблица 7.1. Операции сравнения C++.
| Операция | Проверка | Пример |
| == | Если два значения равны | (score == 100) |
| != | Если два значения не равны | (old != new) |
| > | Если первое значение больше второго | (cost > 50.00) |
| < | Если первое значение меньше второго | (salary < 20000.00) |
| >= | Если первое значение больше или равно второму | (stock_price >= 30.0) |
| <= | Если первое значение меньше или равно второму | (age <= 21) |
Если ваша программа использует операции сравнения для сравнения двух значений, результат сравнения может быть истиной или ложью. Другими словами, два значения или равны (истина), или нет (ложь).
ОПЕРАТОР if
Оператор C++ if позволяет вашим программам осуществлять проверку и затем на основании этой проверки выполнять операторы. Формат оператора if следующий:
if (условие_выполняется) оператор;
Обычно оператор if выполняет проверку, используя операцию сравнения C++. Если результат проверки является истиной, if выполняет оператор, который следует за ним. Следующая программа FIRST_IF.CPP использует оператор if для сравнения значения переменной test_score со значением 90. Если набранные тестовые очки больше или равны 90, программа выведет сообщение пользователю, что он получил А. В противном случае, если значение меньше 90, программа просто завершается:
#include <iostream.h>
void main()
{
int test_score = 95;
if (test_score >= 90) cout << «Поздравляем, вы получили А!» << endl;
}
Как видите, для выполнения проверки программа использует операцию сравнения C++ «больше или равно» (>=). Если результат сравнения значений является истиной, программа выполняет оператор, который следует за if, в данном случае вывод сообщения с использованием cout. Если результат сравнения не является истинным, программа не выводит сообщение. Экспериментируйте с этой программой, изменяя проверочные очки (в том числе и меньше 90), и обратите внимание на работу оператора if.
Представление о простых и составных операторах
При использовании оператора if для условной обработки в некоторых случаях, если условие истинно, программе потребуется выполнить один оператор, а в других случаях несколько операторов. Когда программа выполняет только один оператор, следующий за if, такой оператор называется простым оператором:
if (test_score >= 90) cout << «Поздравляем, вы получили A!» << endl; //——-> Простой оператор
Если программе необходимо выполнить несколько инструкций, когда результат сравнения — истина, операторы должны быть сгруппированы внутри левой и правой фигурных скобок {}. Операторы, которые находятся внутри фигурных скобок, образуют составной оператор, как показано ниже:
if (test_score >= 90)
{
cout << «Поздравляем, вы получили A!» << endl;
cout << «Ваши тестовые очки были » << test_Score << endl;
} //—————–>Составной оператор
ОПЕРАТОР else
В большинстве случаев вашим программам потребуется указать один набор операторов, выполняющийся, если условие истинно, и второй набор, выполняющийся, если условие ложно. Для указания операторов, которые должны выполняться, когда условие ложно, ваши программы должны использовать оператор else. Ниже приведен формат оператора else:
if (условие_истинно)
оператор;
else
оператор;
Следующая программа IF_ELSE.CPP использует оператор if, чтобы проверить, больше тестовые очки или равны 90. Если условие истинно, программа выводит поздравление. Если условие ложно, программа сообщает, что студент должен работать усерднее:
#include <iostream.h>
void main()
{
int test_score =95;
if (test_score >= 90)
cout << «Поздравляю, вы получили А!» << endl;
else
cout << «В следующий раз вы должны» << » работать усерднее!» << endl;
}
ПРИМЕНЕНИЕ СОСТАВНЫХ ОПЕРАТОРОВ ДЛЯ else
Как вы уже знаете, составной оператор представляет собой группу связанных операторов, заключенных между левой и правой фигурными скобками. Когда программа использует else для указания операторов, выполняющихся, если условие ложно, то для указания нескольких операторов можно использовать составной оператор. Следующая программа CMP_ELSE.CPP использует составные операторы как для if, так и для else:
#include <iostream.h>
void main(void)
{
int test_score = 65;
if (test_score >= 90)
{
cout << » Поздравляю, вы получили A!» << endl;
cout << «Ваши тестовые очки были » << test_score << endl;
}
else
{
cout << «Вы должны работать усерднее!» << endl;
cout << «Вы потеряли » << 100 – test_score << » очков » << endl;
}
}
По мере усложнения ваши программы будут проверять разные условия и выполнять один набор операторов, если условие истинно, и другой набор, если условие ложно. Для выполнения такой условной обработки программы используют операторы if-else, как показано ниже:
if (условие_истинно)
оператор;
else
оператор;
Когда программе требуется выполнить несколько операторов, если условие ложно или истинно, вы должны сгруппировать связанные операторы внутри левой и правой фигурных скобок {}:
if (условие_истинно)
{
первый_оператор_для_истины;
второй_оператор_для_истины;
}
else
{
первый_оператор_для_лжи;
второй_оператор_для_лжи;
}
ПРОВЕРКА ДВУХ ИЛИ БОЛЕЕ УСЛОВИЙ
Как вы уже знаете, оператор if позволяет программам проверять определенные условия. По мере усложнения ваших программ возникает необходимость в проверке сразу нескольких условий. Например, программа могла бы проверить, будут ли тестовые очки больше или равны 90, и получит ли студент оценку А. Подобно этому, вы могли бы проверить, есть ли у пользователя собака и долматин ли это. Для выполнения таких проверок можно использовать логическую операцию C++ И (&&). Кроме того, если вы хотите проверить, есть ли у пользователя собака или кошка, вам следует использовать логическую операцию ИЛИ (||). Если программы для проверки нескольких условий используют логические операции И или ИЛИ, поместите каждое условие внутри круглых скобок, как показано ниже:
if ((user_owns_a_dog) && (dog == dalmatian)) //————->Полное условие
Как видите, программа группирует каждое условие внутри своих собственных круглых скобок, которые затем заключаются во внешние круглые скобки.
if ((user_owns_a_dog) && (dog == dalmatian))
Когда ваша программа использует логическую операцию И (&&), то результат полного условия является истинным, только если все проверяемые условия истинны. Если какое-либо условие ложно, то полное условие становится ложным. Например, если у пользователя нет собаки, то предыдущее условие является ложным. Подобно этому, если собака пользователя не долматин, условие является ложным. Чтобы условие было истинным, у пользователя должна быть собака и она должна быть породы долматин. Следующий оператор использует логическую операцию ИЛИ (||), чтобы определить, есть ли у пользователя собака или кошка:
if ((user_owns_a_dog) || (user_owns_a_cat))
При использовании логической операции ИЛИ полное условие будет истинным, если хотя бы одно условие является истинным. Например, если у пользователя есть собака, условие истинно. Если у пользователя есть кошка, условие истинно. Подобно этому, если у пользователя есть и собака, и кошка, условие истинно. Условие будет ложным только в том случае, если у пользователя нет ни собаки, ни кошки.
В C++ истина представляется как ненулевое значение, а ложь как 0
Достоинством C++ является то, что истина представляется как любое ненулевое значение, а ложь как 0. Предположим, ваша программа использует переменную с именем user_owns_a_dog, чтобы определить, есть ли у пользователя собака или нет. Если у пользователя нет собаки, вы можете присвоить этой переменной значение 0 (ложь), как показано ниже:
user_owns_a_dog = 0;
Если у пользователя есть собака, вы можете присвоить этой переменной любое ненулевое значение, например 1:
user_owns_a_dog = 1;
Затем ваши программы могут проверить эту переменную, используя оператор if, как показано ниже:
if (user_owns_a_dog)
Если переменная содержит ненулевое значение, условие оценивается как истина; в противном случае, если переменная содержит 0, условие ложно. Исходя из того, как C++ представляет истину и ложь, предыдущий оператор идентичен следующему:
if (user_owns_a_dog == 1)
Следующая программа DOG_CAT.CPP использует переменные user_owns_a_dog и user_owns_a_cat внутри оператора if, чтобы определить, какие животные есть у пользователя.
#include <iostream.h>
void main()
{
int user_owns_a_dog = 1;
int user_owns_a_cat = 0;
if (user_owns_a_dog)
cout << «Собаки великолепны» << endl;
if (user_owns_a_cat)
cout << «Кошки великолепны» << endl;
if ((user_owns_a_dog) && (user_owns_a_cat))
cout << «Собаки и кошки могут ужиться» << endl;
if {(user_owns_a_dog) II (user_owns_a_cat))
cout << «Домашние животные великолепны!» << endl;
}
Использование операции НЕ в C++
Вы уже знаете, что, когда программа проверяет определенное условие, в ряде случаев она должна выполнить некоторые операторы, если это условие истинно. С другой стороны, вам может потребоваться, чтобы программа выполнила операторы, если условие является не истинным. Операция C++ НЕ — восклицательный знак (!) — позволяет вашим программам проверить, является ли условие не истинным. Например, следующий оператор проверяет, нет ли у пользователя собаки:
if (! user_owns_a_dog)
cout << «вы должны купить собаку» << endl;
Операция НЕ превращает ложь в истину, а истину в ложь. Например, предположим, что у пользователя нет собаки. Следовательно, переменная user_owns_a_dog должна содержать значение 0. Если C++ оценивает условие с Помощью операции НЕ, он использует текущее значение переменной (0) и применяет операцию НЕ. Операция НЕ превращает значение 0 в 1 (истину). Таким образом, полное условие превращается в истину и выполняется соответствующий оператор.
Следующая программа USE_NOT.CPP иллюстрирует использование операции НЕ:
#include <iostream.h>
void main()
{
int user_owns_a_dog = 0;
int user_owns_a_cat = 1;
if (! user_owns_a_dog)
cout << «Вы должны купить собаку» << endl;
if (! user_owns_a_cat)
cout << «Вы должны купить кошку» << endl;
}
Операции C++ И, ИЛИ и НЕ представляют собой логические операции.
ОБРАБОТКА НЕСКОЛЬКИХ УСЛОВИЙ
Программы, представленные в этом уроке, использовали if и else, чтобы указать один набор операторов, который программе следует выполнить, если условие истинно, и другой набор операторов, выполняемых, если условие ложно. Однако в некоторых случаях программам потребуется проверить несколько разных условий. Предположим, например, что вашей программе необходимо определить тестовые очки студента. Для этого программа должна проверить, больше тестовые очки или равны 90, 80, 70, 60 и т. д. Следующая программа SHOWGRAD.CPP использует для этого серию операторов if-else:
#include <iostream.h>
void main()
{
int test_score;
cout << «Введите тестовые очки и нажмите Enter: «;
cin >> test_score;
if (test_score >= 90)
cout << «Вы получили А!» << endl;
else if (test_score >= 80)
cout << «Вы получили В!» << endl;
else if (test_score >= 70)
cout << «Вы получили С» << endl;
else if (test_score >= 60)
cout << «Ваша оценка была D» << endl;
else
cout << «Вы провалили тест» << endl;
}
При выполнении первого оператора if программа проверяет, больше тестовые очки или равны 90. Если это так, программа выводит сообщение пользователю, что он получил А. В противном случае, если тестовые очки не больше или равны 90, программа выполняет следующие else if, чтобы проверить, больше ли тестовые очки или равны 80. Программа повторяет данный процесс до тех пор, пока не определит правильную оценку.
ИСПОЛЬЗОВАНИЕ ОПЕРАТОРА switch
Как вы уже знаете, комбинируя серии операторов if-else, программы могут проверять несколько условий. В предыдущей программе использовались операторы if-else, чтобы определить, находятся ли тестовые очки в данном диапазоне значений. В тех случаях, когда вашим программам необходимо осуществить проверку определенных значений, они могут использовать оператор C++ switch.
Если вы используете оператор switch, вы должны указать условие и затем один или несколько вариантов (case), которые программа попытается сопоставить с условием. Например, следующая программа SWITCH.CPP использует оператор switch для вывода сообщения, основываясь на текущей оценке студента:
#include <iostream.h>
void main()
{
char grade = ‘В’;
switch (grade)
{
case ‘A’: cout << «Поздравляем, вы получили А» << endl; break;
case ‘В’: cout << «Хорошо, у вас В» << endl; break;
case ‘С’: cout << «У вас всего лишь С» << endl; break;
case ‘D’: cout << «Плохо, у вас D» << endl; break;
default: cout << «Ужасно! Учите лучше!» << endl; break;
}
}
Оператор switch состоит из двух частей. Первая часть оператора switch представляет собой условие, которое появляется после ключевого слова switch. Вторая часть представляет собой возможные варианты соответствия. Когда программа встречает оператор switch, она сначала исследует условие, а затем пытается найти среди возможных вариантов тот, который соответствует условию. Если программа находит соответствие, выполняются указанные операторы. Например, в предыдущей программе выбор варианта ‘В’ соответствует условию. Таким образом, программа выводит сообщение, что пользователь получил В. Найдите время для эксперимента с этой программой, изменяя оценку и наблюдая поведение программы. Если же ни один из указанных вариантов не соответствует условию, то выполняется вариант default.
Обратите внимание на использование оператора break в каждом варианте предыдущей программы. Оказывается, если C++ встречает вариант, соответствующий условию оператора switch, то он подразумевает, что все последующие варианты тоже соответствуют условию. Оператор break указывает C++ завершить текущий оператор switch и продолжить выполнение программы с первого оператора, следующего за оператором switch. Если вы удалите операторы break из предыдущей программы, то программа выведет не только требуемое сообщение, но и сообщение для всех последующих вариантов (потому что если один вариант является истинным, то и все последующие варианты в C++ рассматриваются как истинные).
ПОВТОРЕНИЕ ОПЕРАТОРОВ УКАЗАННОЕ ЧИСЛО РАЗ
Одной из наиболее широко используемых операций в ваших программах является повторение одного или нескольких операторов определенное число раз. Например, одна программа могла бы повторять один и тот же оператор, чтобы напечатать пять копий файла, а другая могла бы повторять некоторый Набор операторов 30 раз, чтобы определить, поднялась или упала цена ваших 30 акций. Оператор C++ for предоставляет чрезвычайно простую возможность вашим программам повторять один или несколько операторов указанное число раз.
Если ваша программа использует оператор for (часто называемый циклом for), она должна указать переменную, которая называется управляющей переменной, хранящей количество выполнений цикла. Например, следующий цикл for использует переменную count для хранения количества выполнений цикла. В данном случае цикл будет выполнен десять раз.
for (count = 1; count <= 10; count++)
оператор;
Цикл for состоит из четырех частей. Первые три части управляют количеством выполнений цикла. Сначала оператор count = 1, присваивает переменной управления начальное значение. Цикл for выполняет эту инициализацию один раз при запуске цикла. Далее цикл проверяет условие count <= 10. Если условие истинно, цикл for выполняет следующий оператор. Если условие ложно, цикл завершается и программа продолжает свое выполнение с первого оператора, следующего за циклом. Если условие истинно и цикл for выполняет свой оператор, то после этого цикл увеличивает переменную count, используя оператор count++. Далее программа проверяет условие count <= 10. Если это условие все еще истинно, то опять повторяется выполнение оператора внутри цикла, увеличение и проверка переменной count
for (count = 1; count <= 10; count++)
Инициализация Проверка Увеличение
Следующая программа FIRSTFOR.CPP использует цикл for для вывода на экран дисплея значений от 1 до 100:
#include <iostream.h>
void main()
{
int count;
for (count = 1; count <=100; count++) cout << count <<’ ‘;
}
Как видите, оператор for инициализирует переменную count значением 1. Затем цикл проверяет, меньше ли значение переменной count или равно 100. Если это так, цикл for выполняет соответствующий оператор и затем увеличивает count, повторяя проверку.
Следующая программа ASKCOUNT.CPP выводит сообщение, запрашивающее пользователя ввести число, при котором цикл должен завершиться. Затем программа выводит числа от одного до указанного значения:
#include <iostream.h>
void main()
{
int count;
int ending_value;
cout << «Введите конечное значение и нажмите Enter: «;
cin >> ending_value;
for (count = 0; count <= ending_value; count++)
cout << count << ‘ ‘;
}
Циклы for C++ поддерживают составные операторы
Следующая программа ADD1_100.CPP зацикливает числа от 1 до 100, выводя и добавляя каждое число в общий итог:
#include <iostream.h>
void main()
{
int count;
int total = 0;
for (count = 1; count <= 100; count++)
{
cout << «Прибавляю » << count << » к » << total;
total = total + count;
cout << » получаю » << total << endl;
}
}
Группируя операторы внутри фигурных скобок, цикл for тем самым может выполнить несколько операторов за один проход (называемый umepaцией цикла).
Изменение и увеличение цикла for
Все представленные до настоящего момента циклы for увеличивали управляющую переменную цикла на 1 на каждой итерации цикла. Однако цикл for не обязывает ваши программы увеличивать эту переменную на единицу. Следующая программа BY_FIVES.CPP выводит каждое пятое число в диапазоне от 0 до 100:
#include <iostream.h>
void main(void)
{
int count;
for (count = 0; count <= 100; count += 5)
cout << count << ‘ »;
}
Если вы откомпилируете эту программу, на вашем экране будут отображаться числа 0, 5,10 и т. д. до 100. Обратите внимание, что оператор цикла for использует для увеличения переменную count.
count += 5;
Если вы хотите добавить некоторое значение к текущему значению переменной, а затем присвоить результат той же переменной, C++ позволяет вам сделать это двумя способами. Первый: предположим, вашей программе необходимо добавить значение 5 к переменной count, это можно сделать, как показано ниже:
count = count + 5;
Второй: C++ позволяет вам использовать краткую запись, представленную ниже, для добавления значения 5 к переменной count.
count += 5;
Поскольку это легче записать, то данная краткая форма является общепринятой внутри циклов.
При использовании цикла for вы не обязаны продвигать счетчик в сторону увеличения. Следующая программа CNT_DOWN.CPP использует цикл for для вывода чисел в порядке уменьшения от 100 до 1:
#include <iostream.h>
void main()
{
int count ;
for (count = 100; count >= 1; count–)
cout << count << ‘ ‘;
}
Как видите, цикл for инициализирует переменную count значением 100. На каждой итерации цикл уменьшает значение этой переменной на 1. Цикл завершается, когда переменная count содержит значение 0.
Остерегайтесь бесконечных циклов
Как вы уже знаете, цикл for предоставляет вашим программам способ повторять связанные операторы определенное количество раз. Используя переменную управления, цикл for по существу считает количество выполненных итераций. Когда цикл достигает своего конечного условия, ваша программа прекращает повторение операторов и продолжает свое выполнение с первого оператора, следующего за циклом for.
К сожалению, из-за ошибок в программах в некоторых случаях цикл никогда не достигает своего завершающего условия и, таким образом, зацикливается навсегда (или до тех пор, пока вы не прервете программу). Такие не завершающиеся циклы называются бесконечными циклами. Другими словами, это циклы, не имеющие способа для завершения. Например, следующий оператор for создает бесконечный цикл:
for (count = 0; count < 100; wrong_variable++)
// операторы
Как видите, цикл for использует переменную count в качестве своей управляющей переменной. Однако в секции цикла увеличения программа увеличивает не ту переменную. В результате цикл никогда не увеличивает переменную count, и она никогда не будет иметь значение больше или равно 100. Таким образом, этот цикл превращается в никогда не завершающийся бесконечный цикл.
Важно обратить внимание, что циклы for не ограничиваются использованием переменных типа int в качестве их управляющих переменных. Например, следующая программа LOOPVAR.CPP использует переменную типа char для вывода букв алфавита внутри одного цикла и переменную типа float для вывода чисел с плавающей точкой внутри другого цикла:
#include <iostream.h>
void main()
{
char letter;
float value;
for (letter = ‘A’; letter <= ‘Я’; letter++)
cout << letter;
cout << endl;
for (value = 0.0; value <= 1.0; value += 0.1)
cout << value << ‘ ‘;
cout << endl;
}
Если вы откомпилируете и запустите эту программу, на экране появится следующий вывод:
АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9
ЦИКЛ while
Как вы знаете, цикл C++ for позволяет вашим программам повторять один или несколько операторов определенное количество раз. Однако в некоторых случаях программе необходимо повторять операторы, пока удовлетворяется (истинно) некоторое условие. Например, в следующих уроках вы узнаете, как читать содержимое файла. Такие программы могли бы повторять цикл, пока не встретится конец файла. В ситуациях, когда программам необходимо выполнять цикл, пока удовлетворяется некоторое условие (но не обязательно определенное количество раз), ваши программы могут использовать оператор C++ while. Общий формат оператора while выглядит так:
while (условие_верно)
оператор;
Если ваша программа встречает оператор while, она проверяет заданное условие. Если условие истинно, программа выполняет операторы цикла while. После выполнения последнего оператора в цикле, цикл while опять проверяет условие. Если условие все еще истинно, повторяются операторы цикла и повторяется данный процесс. Когда условие, наконец, становится ложным, цикл завершается и программа продолжает свое выполнение с первого оператора, следующего за циклом. Следующая программа GET_YN.CPP просит вас ввести Д для да или Н для нет. Затем программа использует цикл while для чтения символов с клавиатуры, пока пользователь не введет Д или Н. Если пользователь вводит значение, отличное от Д или Н, программа сигналит встроенным динамиком, записывая символ сигнала ‘\а’ в выходной поток cout:
#include <iostream.h>
void main()
{
int done = 0; // Устанавливается в состояние „истина», если введены Д или Н char letter;
while (! done)
{
cout << «\nВведите Д или Н» << » и нажмите Enter для продолжения: «;
cin >> letter;
if ((letter == ‘Д’) II (letter == ‘д’))
done = 1;
else if ((letter == ‘Н’) II (letter == ‘н’))
done = 1;
else cout << ‘\а’; // Играть сигнал динамика для неверного символа
}
cout << «Вы ввели букву » << letter << endl;
}
Как видите, цикл while тоже поддерживает несколько операторов, сгруппированных внутри левой и правой фигурных скобок. В данном случае программа использует переменную done для управления циклом. Пока программа не завершится (т. е. пока пользователь не введет Д или Н), цикл продолжает выполняться. Когда пользователь вводит Д или Я, программа устанавливает переменную done в значение истина и цикл завершается.
ВЫПОЛНЕНИЕ ОПЕРАТОРОВ ПО КРАЙНЕЙ МЕРЕ ОДИН РАЗ
Как вы уже знаете, цикл C++ while позволяет вашим программам повторять набор операторов, пока данное условие удовлетворяется. Когда программа встречает оператор while, она сначала оценивает заданное условие. Если условие истинно, программа входит в цикл. Если условие ложно, операторы цикла while никогда не выполняются. В зависимости от назначения ваших программ, возможны ситуации, когда некоторый набор операторов должен выполняться по крайней мере один раз, а затем выполнение, основываясь на некотором условии, может повторяться. В подобном случае ваши программы могут использовать цикл do while:
do
{
операторы;
}
while (условие_истинно);
Если программа встречает цикл do while, она входит в цикл и запускает выполнение операторов, содержащихся в цикле. Затем программа оценивает заданное условие. Если условие истинно, программа возвращается к началу цикла:
do <—————————————-
{ |
операторы; |
} |
while (условие_истинно); ———-
Если условие ложно, программа не повторяет инструкции цикла, продолжая вместо этого выполнение с первого оператора, следующего за циклом. Обычно цикл do while используется для отображения пунктов меню и затем обработки выбора пользователя. Вам требуется, чтобы программа отобразила меню по крайней мере один раз. Если пользователь выбирает какой-либо пункт меню, кроме Quit, программа выполнит пункт, а затем отобразит меню снова (повторяя оператор цикла). Если пользователь выбирает Quit, цикл завершится и программа продолжит свое выполнение с первого оператора после цикла.
Похожие записи:
