Часть 1. Изучение основ

Урок 1. Создание вашей первой программы

Все вы использовали компьютерные программы, такие как текстовый процессор, электронные таблицы и даже Microsoft Windows 95. Компьютерные программы, или программное обеспечение, представляют собой файлы, содержащие инструкции, которые указывают компьютеру, что следует делать. Если вы работаете в среде MS-DOS или Windows, то, например, файлы с расширениями ЕХЕ и СОМ содержат команды, которые компьютер может выполнять. Другими словами, файлы содержат специальные инструкции, выполняемые компьютером, обычно одну за другой, для решения определенной задачи. При создании программы вы указываете инструкции, которые компьютер должен выполнить. Из этого урока вы узнаете, как указать такие инструкции с помощью операторов C++. К концу данного урока вы освоите следующие основные концепции:

• При создании программы используйте текстовый редактор, чтобы ввести операторы C++ в исходный файл программы.

• Для преобразования операторов программы C++ в выполнимую программу, в единицы и нули, которые понимает компьютер, используйте специальную программу — компилятор C++.

• Для изменения или исправления программы используйте текстовый редактор.

• При нарушении одного (или более) правил программирования на C++ компилятор выдаст на экран сообщения о синтаксических ошибках. Вам следует отредактировать программу, чтобы исправить ошибки, а затем запустить компилятор снова.

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

Лучший способ понять процесс создания и компиляции программы — построить простую программу на C++. Давайте этим займемся!

СОЗДАНИЕ ПРОСТОЙ ПРОГРАММЫ

Как и следовало ожидать, ваша первая программа на C++ называется FIRST.СРР. При создании программ на C++ используйте расширение СРР, чтобы другие могли понять, что этот файл содержит программу на C++. Когда вы позже запустите эту программу, она выведет на экран дисплея сообщение Учимся программировать на языке C++/Следующий пример вывода показывает подсказку командной строки (в данном примере С:\>), вводимую вами командную строку (имя программы FIRST, за которым следует ENTER) и вывод программы на экран:

С:\> FIRST <ENTER>

Учимся программировать на языке C++!

Как известно, при программировании вы можете работать в среде, основанной на командной строке, например MS-DOS или UNIX, или в среде типа Windows. Для упрощения вывода в данной книге подразумевается, что вы работаете из командной строки. В этом случае для выполнения программы FIRST.EXE вы должны ввести имя программы FIRST в ответ на системную подсказку и затем нажать ENTER.

Для начала вам следует использовать текстовый редактор, например EDIT (поставляется с MS-DOS), для создания файла, который содержит операторы программы и называется исходным файлом. Не используйте текстовый процессор, такой как Word или WordPerfect, для создания исходного файла программы. Как известно, текстовые процессоры позволяют вам создавать форматированные документы, которые могут содержать полужирный текст, выровненные поля, а также другие особенности. Чтобы отформатировать документы таким образом, текстовый процессор вставляет специальные (скрытые) символы внутрь документа. Такие символы могут включать или выключать курсив или выбирать определенную ширину полей. Несмотря на то что такие специальные символы имеют смысл для текстового процессора, C++ их не поймет и эти символы приведут к ошибкам.

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

#include <iostream.h>

void main(void)

{
             cout << "Учимся программировать на языке C++!";
}

Не беспокойтесь, если операторы C++ не имеют для вас смысла. Вы узнаете назначение каждого из них из урока 2. А пока обратите особое внимание на ваш ввод. Удостоверьтесь, например, что вы ввели верное количество кавычек, точек с запятой и скобок. Еще раз более внимательно проверьте операторы своей программы. Если они верны, сохраните операторы в файле FIRST. СРР

Что означает имя?

При создании программы на C++ вы вносите операторы программы в исходный файл. Применяйте расширение СРР, чтобы другие программисты могли понять, что данный файл содержит программу на C++. Далее используйте имя файла, которое указывает назначение программы. Например, если вы создаете финансовую программу, можно использовать имя BUDGET.CPP. Аналогичным образом программу, которая вычисляет оклады в фирме, вы можете назвать SALARY. СРР. Чтобы избежать путаницы, никогда не используйте для названия программы имя существующей команды MS-DOS, например COPY или DEL.

КОМПИЛЯЦИЯ ВАШЕЙ ПРОГРАММЫ

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

Другими словами, компилятор просматривает исходный файл, содержащий операторы программы на C++. Если ваши операторы не нарушают ни одно правило языка C++, компилятор преобразует их в машинный язык (единицы и нули), который компьютер может выполнить. Компилятор хранит машинный язык в выполняемом файле, имеющем, как правило, расширение ЕХЕ. Если файл ЕХЕ существует, вы можете запустить программу, вводя ее имя в ответ на командную подсказку.

В зависимости от используемого вами компилятора, команды, которые вы применяете для его вызова, будут различны. Например, при использовании Borland C++ вам следует компилировать программу FIRST.CPP с помощью команды ВСС:

C:\> BCC FIRST.CPP <ENTER>

Если вы применяете не Borland C++, обратитесь к документации, поставляемой с вашим компилятором, чтобы определить правильную команду для его запуска. По окончании работы компилятор создаст выполнимую программу и сохранит ее в файле на диске. В среде MS-DOS файл выполни-

мой программы будет иметь расширение ЕХЕ, например FIRST.EXE. Если при компиляции программы компилятор выдает сообщения об ошибках, отредактируйте свой исходный файл и сравните каждый символ исходного файла с символами, которые приведены в этой книге. Исправьте все ошибки, сохраните сделанные изменения, а затем откомпилируйте про грамму второй раз. После того как вы успешно откомпилировали свою программу, запустите ее, вводя имя программы в ответ на командную подсказку как это было показано выше.

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

При создании программы вы используете язык программирования (такой как C++), чтобы указать инструкции, выполняемые компьютером. Применяя текстовый редактор, вы вносите операторы программы в исходный файл. Далее используется специальная программа — компилятор, которая преобразует ваш исходный файл в машинный язык (единицы и нули, понимаемые компьютером). Если компиляция прошла успешно, результатом будет файл выполнимой программы. Однако если вы допустили одну или несколько ошибок или нарушили какое-либо правило C++, компилятор выдаст на экран сообщения об ошибках, и для их исправления вам следует заново отредактировать исходный файл.

Если вы работаете на большой машине или мини-ЭВМ, у вас должен быть компилятор, доступный для вас и других пользователей вашей системы. Если же вы используете ПК, вам следует приобрести и установить компилятор, такой как Borland C++ или Microsoft Visual C++.

СОЗДАНИЕ ВТОРОЙ ПРОГРАММЫ

Хочется надеяться, что вы смогли успешно откомпилировать и выполнить программу FIRST. CPP. Если это так, используйте ваш текстовый редактор, чтобы создать второй программный файл с именем EASY. CPP, который содержит следующие операторы программы:

#include <iostream.h>

void main(void)

{
   cout << "Программировать на C++ просто!";
}

Как и ранее, сохраните свои операторы программы на C++ в исходном файле и вызовите компилятор, указав имя файла программы в командной строке компилятора. В случае Borland C++ используйте следующую команду для компиляции программы:

С:\> ВССEASY.CPP <ENTER>

Если компиляция программы прошла успешно, компилятор создаст выполнимую программу с именем EASY.EXE. Когда вы запустите эту программу, на вашем экране появится следующее сообщение:

С.\> EASY <ENTER>

Программировать на C++ просто!

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

cout << "Программировать на C++ очень просто!";

Сохраните ваше изменение в исходном файле и откомпилируйте программу. После успешной компиляции запустите программу, как показано ниже:

С:\> EASY <ENTER>

Программировать на C++ очень просто!

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

#include <iostream.h>

void main(void)

{
   cout << "Программировать на C++ очень просто!";
   cout << endl << "Можно расслабиться!";
}

Сохраните ваши изменения в исходном файле. Затем запустите программу, как показано ниже:

С:\> EASY <ENTER>

Программировать на C++ очень просто!

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

C:\> EASY <ENTER>

Программировать на C++ очень просто!

Можно расслабиться!

ИЗУЧЕНИЕ СИНТАКСИЧЕСКИХ ОШИБОК

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

Компилятор C++ не может создать выполнимую программу, пока не будут исправлены все синтаксические ошибки. Чтобы понять процесс обнаружения и исправления синтаксических ошибок, создайте следующую программу с именем SYNTAX. CPP:

#include <iostream.h>

void main(void)

{
   cout << Заключайте сообщение в кавычки;
}

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

С:\> ВСС SYNTAX.CPP <ENTER>

Borland C++ Version 4.00 Copyright (с) 1993 Borland

International syntax.cpp:

Error syntax.cpp 5: Undefined symbol 'Заключайте' in function main()

Error syntax.cpp 5: Statement missing; in function main() *** 2 errors in Compile ***

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

cout << "Заключайте сообщение в кавычки";

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

Изучение синтаксических ошибок

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

РАБОТА В СРЕДЕ ТИПА WINDOWS

Для упрощения в каждом из предыдущих примеров предполагается, что вы работаете в среде, основанной на командной строке, например MS-DOS или UNIX. Однако сегодня большинство программистов на C++ программируют в среде типа Windows, такой как Visual C++, или интегрированной среде разработки фирмы Borland. При программировании в среде типа Windows операторы программы не отличаются от тех, которые показаны здесь. Другими словами, операторы C++ в программе FIRST.CPP, написанной в Windows, идентичны тем, которые вы будете использовать в среде, основанной на командной строке. Что изменяется в Windows, так это процесс компиляции и запуска программы.

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

Рис.1. Среда программирования Windows.

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

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

Из этого урока вы узнали, как создавать и компилировать программы на C++! В уроке 2 вы получите более подробный обзор операторов, которые использовались в программах, созданных в данном уроке. Вы изучите использование фигурных скобок {}, ключевых слов, таких как void, а также как научить программы направлять вывод на экран.

До изучения урока 2 убедитесь, что вы освоили следующие основные концепции:

1.       

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

2.      Вы создаете программы на C++, используя текстовый редактор.

3.      Вы сохраняете свои программы на C++ в исходных файлах, для которых используется расширение СРР.

4.      Компилятор преобразует операторы программы на C++ в единицы и нули — машинный язык, который понимает компьютер.

5.      Подобно всем языкам, в C++ существует набор правил, называемых синтаксисом.

6.      Если вы нарушаете правила синтаксиса, компилятор выводит сообщение, описывающее ошибку.

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

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

Урок 2. Более внимательный взгляд на C++

В уроке 1 вы создали несколько программ на C++. В то время ваша цель заключалась в том, чтобы понять процесс создания и компиляции программ на C++, а не в том, чтобы понять операторы C++. В данном уроке вы впервые более внимательно рассмотрите операторы, из которых состоит программа на C++. Вы увидите, что большинство программ на C++ придерживаются одного и того же формата: начинаются с одного или нескольких операторов # include, содержат строку void main(void), а затем набор операторов, сгруппированных между левой и правой фигурными скобками. Из этого урока вы поймете, что эти несколько запугивающие операторы реально очень просто освоить. К концу данного урока вы изучите следующие основные концепции:

·         Оператор # include обеспечивает преимущества использования заголовочных файлов, которые содержат операторы C++ или программные определения.

·         Основная часть программы на C++ начинается с оператора void main(void).

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

·         При выводе на экран ваши программы будут широко использовать выходной поток cout.

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

ВЗГЛЯД НА ОПЕРАТОРЫ ПРОГРАММЫ

В уроке 1 вы создали на C++ программу FIRST.CPP, которая содержала следующие операторы:

#include <iostream.h>

void main(void)

{
   cout << "Учимся программировать на языке С++!";
}

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

#include <iostream.h>

void main (void)

{
   cout << "Учимся программировать << "на языке С++!";
}

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

ПРЕДСТАВЛЕНИЕ ОБ ОПЕРАТОРЕ #include

Каждая программа, представленная в уроке 1, начинается со следующего оператора # include:

#include <iostream.h>

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

Файлы с расширением h, которые вы включаете в начало (или заголовок) вашей программы, называются заголовочными файлами. Если вы посмотрите на каталог, содержащий файлы вашего компилятора, то найдете подкаталог с именем INCLUDE, в котором находятся разные заголовочные файлы. Каждый заголовочный файл содержит определения, предоставляемые компилятором для различных операций. Например, существует заголовочный файл, который содержит определения для математических операций, другой заголовочный файл описывает файловые операции и т. д.

Заголовочные файлы представляют собой файлы в формате ASCII, следовательно, вы можете вывести их содержимое на экран или принтер. В данный момент не беспокойтесь о содержимом заголовочных файлов. Просто поймите, что оператор # include позволяет вам использовать эти файлы. Все программы на C++, созданные вами в процессе изучения этой книги, содержат операторы # include, которые вы должны применять в ваших программах.

Заголовочные файлы C++

Каждая создаваемая вами программа на C++ начинается с одного или нескольких операторов #include. Эти операторы указывают компилятору включить содержимое заданного файла (заголовочного файла) в вашу программу, как если бы программа содержала операторы, которые находятся во включаемом файле. Заголовочные файлы содержат определения, используемые компилятором для операций различных типов. Существуют заголовочные файлы, которые определяют операции В/В (ввода/вывода) C++, системные функции (например, функции, возвращающие текущие дату и время) и многое другое.

Заголовочные файлы, подобно программам на C++, представляют собой файлы в формате ASCII, содержимое которых вы можете просмотреть или напечатать. Чтобы лучше понять содержимое заголовочных файлов, найдите время для того, чтобы напечатать заголовочный файл IOSTREAM.H, содержимое которого вы будете использовать в каждой создаваемой вами программе на C++. Обычно заголовочный файл IOSTREAM.H расположен в подкаталоге с именем INCLUDE, который находится в каталоге, содержащем файлы компилятора C++. Используйте текстовый редактор, чтобы просмотреть и напечатать содержимое заголовочных файлов.

Замечание: Никогда не изменяйте содержимое заголовочных файлов. Это может привести к ошибкам компиляции в каждой создаваемой вами программе.

ЧТОТАКОЕvoid main(void)

При создании программы на C++ ваш исходный файл будет содержать множество операторов. Как вы поймете в процессе изучения, порядок, в котором операторы появляются в программе, не обязательно должен совпадать с порядком, в котором операторы будут выполняться при запуске программы. Каждая программа на C++ имеет один вход, с которого начинается выполнение программы, — главную программу. В программах на C++ оператор void main(void) указывает стартовую точку вашей программы.

По мере того как ваши программы становятся больше и сложнее, вы будете делить их на несколько небольших легко управляемых частей. При этом оператор void main(void) указывает начальные (или главные) операторы программы — часть программы, которая выполняется первой.

Представление о главной программе

Исходные файлы C++ могут содержать очень много операторов. При запуске программы оператор void main(void) определяет главную программу, содержащую первый выполняемый оператор. Ваши программы на C++ должны всегда включать один и только один оператор с именем main.

При рассмотрении больших программ на C++ ищите main, чтобы определить операторы, с которых начинается выполнение программы.

Использование void

Как только ваша программа становится более сложной, вы должны разделить ее на небольшие более легко управляемые части, называемые функциями. Функция представляет собой простой набор операторов внутри программы, выполняющих определенную задачу. Например, при создании программы платежных документов, вы могли бы создать функцию с именем salary, вычисляющую оклад служащих. Аналогичным образом, если вы пишете математическую программу, вы могли бы создать функции с именами square_root или cube, которые возвращают результат определенных математических операций. Если ваша программа использует функцию, функция выполняет свою задачу и затем возвращает свой результат программе.

Каждая функция в вашей программе имеет уникальное имя. А каждая программа имеет по крайней мере одну функцию. Каждая программа из урока 1 имела только одну функцию с именем main. Урок 9 предоставляет более подробный обзор функций. В данный момент просто имейте в виду, что функция состоит из нескольких связанных по смыслу операторов, выполняющих определенную задачу.

При исследовании различных программ на C++ вы будете постоянно сталкиваться со словом void. Программы используют слово void для указания того, что функция не возвращает значения или не имеет значений, передаваемых в нее. Например, если вы используете среду MS-DOS или UNIX, программа может завершить свое выполнение с возвратом операционной системе значения статуса, которое может быть проверено командным файлом. Командные файлы MS-DOS проверяют выходной статус программы, используя команду IF ERRORLEVEL. Например, предположим, что программа с именем PAYROLL. EXE завершается с одним из следующих выходных значений статуса в зависимости от результата обработки:

Внутри командного файла MS-DOS вы можете проверить результат работы программы, используя команду IF ERRORLEVEL:

PAYROLL

IF ERRORLEVEL 0 IF NOT ERRORLEVEL 1 GOTO SUCCESSFUL
IF ERRORLEVEL 1 IF NOT ERRORLEVEL 2 GOTO NO_FILE
IF ERRORLEVEL 2 IF NOT ERRORLEVEL 3 GOTO NO_PAPER
REM Далееидутдругиекоманды

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

void main (void) //— -------> Программа не возвращает значение

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

void main ( void ) //----------------------> Программа не использует аргументы командной строки

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

ПРЕДСТАВЛЕНИЕ О ГРУППИРУЮЩИХ ОПЕРАТОРАХ { }

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

ИСПОЛЬЗОВАНИЕ cout ДЛЯ ОТОБРАЖЕНИЯ ВЫВОДА НА ЭКРАН

Все программы на C++, созданные вами в уроке 1, выводили сообщения на экран. Чтобы вывести сообщение, программы использовали cout и двойной знак "меньше" (<<), как показано ниже:

cout << "Привет, C++!";

Слово cout представляет собой выходной поток, который C++ назначает на стандартное устройство вывода операционной системы. По умолчанию операционная система назначает стандартное устройство вывода на экран дисплея. Чтобы вывести сообщение на экран, вы просто используете двойной символ "меньше" (называемый оператором вставки) с выходным потоком cout. Из урока 3 вы узнаете, что можно использовать оператор вставки для передачи символов, чисел и других знаков на экран.

Представление о выходном потоке cout

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

cout << "Это сообщение появляется первым,";
cout << " а за ним следует настоящее сообщение.";

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

Это сообщение появляется первым, а за ним следует настоящее сообщение.

Оператор вставки (<<) называется так, потому что позволяет вашей программе вставлять символы в выходной поток.

Вы уже знаете, что выходной поток cout по умолчанию соответствует вашему экрану. Другими словами, когда ваши программы посылают вывод в cout, вывод появляется на экране. Однако, используя операторы переназначения вывода операционной системы, вы можете послать вывод программы на принтер или в файл. Например, следующая команда предписывает MS-DOS направить вывод программы FIRST.EXE на принтер, а не на экран:

С:\> FIRST > PRN <ENTER>

Как вы узнаете из Урока 3, с помощью cout в C++ можно выводить символы, целые числа, например 1001, и числа с плавающей точкой, например 3.12345. Из Урока 8 вы узнаете, что в C++ существует также входной поток с именем cin, который ваши программы могут использовать для чтения информации, вводимой с клавиатуры.

ЧТО ВЫ ДОЛЖНЫ ЗНАТЬ

В этом уроке обсуждались некоторые общие вопросы, с которыми вы столкнетесь в программах на C++. Из Урока 3 вы узнаете, как использовать cout для вывода символов, целых чисел и значений с плавающей точкой. Вы также узнаете, как форматировать вывод. До изучения урока 3 убедитесь, что вы освоили следующие основные концепции:

1.       

1.      Большинство программ на C++ начинаются с оператора # include, который предписывает компилятору включить содержимое заданного заголовочного файла в программу.

2.      Заголовочные файлы содержат определения, предоставляемые компилятором, которые ваши программы могут использовать.

3.      Исходный файл может состоять из множества операторов; оператор void main(void) указывает начало главной программы, которая содержит первый выполняемый оператор программы.

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

5.      Большинство программ на C++ используют выходной поток cout для вывода информации на экран; однако, используя операторы переназначения В/В операционной системы, вы можете перенаправить вывод cout в файл, устройство (например, принтер) или даже сделать его входом другой программы.

Урок З. Вывод сообщений на экран

Все программы на C++, созданные вами в уроках 1 и 2, использовали выходной поток cout для вывода сообщений на экран. В этом уроке вы будете использовать cout для вывода символов, целых чисел, например 1001, и чисел с плавающей точкой, например 0.12345. К концу данного урока вы освоите следующие основные концепции:

6.      Для вывода символов и чисел на экран вы можете использовать выходной поток cout.

7.      В C++ можно использовать с cout специальные символы для вывода табуляции или новой строки и даже для воспроизведения звука на вашем компьютере.

8.      В C++ можно легко отображать числа в десятичном, восьмеричном (по основанию 8) или шестнадцатеричном (по основанию 16) формате.

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

10.  Используя выходной поток cerr, ваши программы могут посылать сообщения на стандартное устройство ошибок, избавляя пользователей от необходимости переназначения сообщений.

11.  Вы можете форматировать вывод вашей программы, используя модификатор setw внутри выходного потока.

Почти все создаваемые вами программы на C++ используют cout для вывода сообщений на экран. Из этого урока вы узнаете, как лучше использовать сом/.

ИСПОЛЬЗОВАНИЕ cout ДЛЯ ВЫВОДА ЧИСЕЛ

До сих пор созданные вами программы использовали сом/ для вывода символьных строк (букв и чисел, взятых в кавычки). Теперь вы узнаете, что сом/ можно также использовать для вывода чисел. Следующая программа 1001.СРР выводит число 1001 на ваш экран:

#include <iostream.h>

void main(void)

{
   cout << 1001;
}

Откомпилируйте и запустите эту программу. На вашем экране будет отображено число 1001, как показано ниже:

С:\> 1001 <ENTER>

1001

Далее отредактируйте программу и измените оператор cout , чтобы вывести число 2002, как показано ниже:

cout << 2002;

Кроме отображения целых чисел (чисел без десятичной точки), сом/также позволяет вашим программам отображать числа с плавающей точкой, например 1.2345. Следующая программа FLOATING.CPP использует сом/для вывода числа 0.12345 на экран:

#include <iostream.h>

void main(void)

{
   cout << 0.12345;
}

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

С:\> FLOATING <ENTER>

0.12345

ВЫВОД НЕСКОЛЬКИХ ЗНАЧЕНИЙ ОДНОВРЕМЕННО

Как вы уже знаете, двойной знак "меньше" является операцией вставки (эта операция вставляет символы в выходной поток для отображения). С помощью cout вы можете использовать несколько операций вставки в пределах одного оператора. Например, следующая программа 1001ТОО.СРР использует эту операцию четыре раза для отображения числа 1001 на вашем экране:

#include <iostream.h>

void main(void)

(
   cout << 1 << 0 << 0 << 1;
}

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

С:\> 1001TOO <ENTER>

1001

Каждый раз, когда в C++ встречается операция вставки, число или символы просто добавляются к тем, что находятся в настоящее время в выходном потоке. Следующая программа SHOW1001.CPP с помощью cout выводит символьную строку и число:

#include <iostream.h>

void main(void)

{
   cout << "Мое любимое число равно " << 1001;
}

Обратите внимание, что пробел, следующий за словом равно (внутри кавычек), служит для отделения числа 1001 от этого слова. Без пробела число сливается со следующим словом (равно 1001). Подобным образом следующая программа 1001MID.CPP отображает число 1001 в середине символьной строки:

#include <iostream.h>

void main(void)

{
   cout << "Число " << 1001 << " мне очень нравится";
}

Как и ранее, обратите внимание на расстановку пробелов до и после числа 1001.

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

#include <iostream.h>

void main(void)

{
   cout << "B " << 20 << " лет мой оклад был " << 493.34 << endl;
}

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

С:\> MIXMATCH <ENTER>

В 20 лет мой оклад был 493.34

ИСПОЛЬЗОВАНИЕ СПЕЦИАЛЬНЫХ СИМВОЛОВ ВЫВОДА

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

Если необходимо переместить курсор в начало следующей строки, можно поместить символ новой строки (\n) в выходной поток. В C++ вам предоставляется два разных способа генерации новой строки. Во-первых, вы можете поместить символы \n внутри символьной строки. Например, следующая программа TWOLINES.CPP отображает свой вывод в виде двух строк, используя символ новой строки:

#include <iostream.h>

void main(void)
{
   cout << "Это строка один\nЭто строка два";
}

Когда вы откомпилируете и запустите эту программу, символ новой строки обеспечит вывод двух строк, как показано ниже:

С:\> TWOLINES <ENTER>

Это строка один

Это строка два

Если вы не выводите символьную строку, можете поместить символ новой строки внутри одинарных кавычек. Например, следующая программа NEWLINES.CPP выводит числа 1, 0, 0 и 1, каждое на своей собственной строке:

#include <iostream.h>

void main(void)
{
   cout << 1 << '\n' << 0 << '\n' << 0 << '\n' << 1;
}

В дополнение к использованию символа новой строки для продвижения курсора в начало следующей строки ваши программы могут использовать символ endl (конец строки). Следующая программа ENDL.CPP иллюстрирует использование endl для продвижения курсора в начало новой строки:

#include <iostream.h>

void main(void)

{
   cout << "А теперь..." << endl
    << "Учимся программировать на языке C++";
}

Как и ранее, когда вы откомпилируете и запустите эту программу, на экране будет отображен вывод программы в виде двух строк:

C:\> ENDL <ENTER>

А теперь

Учимся программировать на языке C++

Наконец, следующая программа ADDRESS.CPP выводит адрес издательства "Jamsa Press" в несколько строк:

#include <iostream.h>

void main(void)

{
   cout << "Jamsa Press" << endl;
   cout << "2975 South Rainbow, Suite I" << endl;
   cout << "Las Vegas, NV 89102" << endl;
}

Другие специальные символы

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

Замечание: При использовании специальных символов, перечисленных в табл. 3.1, вам следует располагать их внутри одинарных кавычек, если вы используете данные символы сами по себе, например '\n', или внутри двойных кавычек, если вы используете их внутри строки, например "Привem\nMup!".

Следующая программа SPECIAL.CPP использует специальные символы сигнала (\а) и табуляции (\t) для выдачи звука на встроенный динамик компьютера и затем выводит слова Звонок Звонок Звонок, разделенные табуляцией:

#include <iostream.h>

void main(void)

{
   cout << "3вонок\a\tЗвонок\a\tЗвонок\a";
}

ВЫВОД ВОСЬМЕРИЧНЫХ И ШЕСТНАДЦАТЕРИЧНЫХ ЗНАЧЕНИЙ

Программы, представленные в этом уроке до сих пор, выводили числа в десятичном виде. В зависимости от назначения ваших программ вам, возможно, потребуется выводить числа в восьмеричном или шестнадцатеричном виде. Для этого можно разместить модификаторы dec, oct и hex внутри выходного потока. Следующая программа ОСТНЕХ.СРР использует эти модификаторы для вывода значений в десятичном, восьмеричном и шестнадцатеричном виде:

#include <iostream.h>

void main(void)

{
   cout << "Восьмеричный: " << oct << 10 << ' ' << 20 << endl;
   cout << "Шестнадцатеричный: " << hex << 10 << ' ' << 20 << endl;
   cout << "Десятичный: " << dec << 10 << ' ' << 20 << endl;
}

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

С:\> OCTEX <ENTER>

Восьмеричный: 12 24

Шестнадцатеричный: а 14

Десятичный: 10 20

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

ВЫВОД НА СТАНДАРТНОЕ УСТРОЙСТВО ОШИБОК

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

Если вашей программе нужно вывести сообщение об ошибке, вы должны использовать выходной поток cerr. C++ связывает cerr со стандартным устройством ошибок операционной системы. Следующая программа CERR.CPP использует выходной поток cerr для вывода на экран сообщения "Это сообщение появляется всегда ":

#include <iostream.h>

void main(void)

{
    cerr << "Это сообщение появляется всегда";
}

Откомпилируйте и запустите эту программу. Далее попытайтесь перенаправить вывод программы в файл, используя оператор переназначения вывода:

С:\> CERR > FILENAME.EXT <ENTER>

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

УПРАВЛЕНИЕ ШИРИНОЙ ВЫВОДА

Несколько предыдущих программ выводили числа на экран. Чтобы гарантировать правильное отображение этих чисел (с правильной расстановкой пробелов), программы включали пробелы до и после чисел. При выводе на cout или cerr ваши программы могут указать ширину вывода каждого числа, используя модификатор setw (установка ширины). С помощью setw программы указывают минимальное количество символов, занимаемое числом. Например, следующая программа SETW.CPP использует модификатор setw для выбора ширины 3, 4, 5 и 6 для числа 1001. Чтобы использовать модификатор setw, ваша программа должна включать заголовочный файл iomanip.h:

#include <iostream.h>

#include <iomanip.h>

void main (void)

{
   cout << "Моелюбимоечислоравно" << setw(3) << 1001 << endl;
   cout << "Моелюбимоечислоравно" << setw(4) << 1001 << endl;
   cout << "Моелюбимоечислоравно" << setw(5) << 1001 << endl;
   cout << "Моелюбимоечислоравно" << setw(6) << 1001 << endl;
}

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

С:\> SETW <ENTER>

Мое любимое число равно1001

Мое любимое число равно1001

Мое любимое число равно 1001

Мое любимое число равно 1001

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

Замечание: Предыдущая программа использует заголовочный файл IOMANIP.H. Вам, возможно, понадобится сейчас напечатать и исследовать содержимое этого файла. Как и в случае с заголовочным файлом IOSTREAM.H вы найдете данный файл внутри подкаталога INCLUDE, который находится в каталоге с файлами вашего компилятора.

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

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

1.      Выходной поток cout позволяет вам выводить символы и числа.

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

3.      Для продвижения курсора в начало следующей строки программы могут создать новую строку, используя символ \n или модификатор endl.

4.      Модификаторы dec, oct и hex позволяют программам выводить значения в десятичном, восьмеричном и шестнадцатеричном виде.

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

6.      С помощью модификатора setw ваши программы могут управлять шириной вывода чисел.

Урок 4. Программы хранят информацию в переменных

Все программы, представленные в уроках 1—3, были очень простыми. Однако по мере того, как ваши программы начинают выполнять более многоплановые задачи, они должны хранить информацию во время выполнения. Например, программе, печатающей файл, нужно знать имя файла и, возможно, число копий, которые вы хотите напечатать. В процессе выполнения программы хранят такую информацию в памяти компьютера. Чтобы использовать определенные ячейки памяти, программы применяют переменные. Проще говоря, переменная представляет собой имя ячейки памяти, которая может хранить конкретное значение. В этом уроке описано, как создавать и использовать переменные в программах на C++. К концу данного урока вы освоите следующие основные концепции:

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

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

3.      Чтобы присвоить значения переменной, используйте оператор присваивания C++ (знак равно).

4.  Для вывода значения переменной на экран программы используют выходной поток cout.

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

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

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

ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ В ПРОГРАММАХ

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

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

Таблица 4.1. Типы переменных C++.

Прежде чем вы сможете использовать переменную, ваша программа должна ее объявить. Другими словами, вам следует представить переменную компилятору C++. Чтобы объявить переменную в программе, вам следует указать тип переменной и ее имя, по которому программа будет обращаться к данной переменной. Указывайте тип и имя переменной после открывающей фигурной скобки главной программы, как показано ниже:

тип_переменной имя_переменной;

Как правило, тип переменной будет одним из типов, перечисленных в табл. 4.1. Выбираемое вами имя переменной должно нести смысловую нагрузку, которая описывает (для всех, кто читает вашу программу) использование переменной. Например, ваша программа могла бы использовать переменные, такие как employee_name, employee_age и т. д. Обратите внимание на точку с запятой, которая следует за именем переменной. В C++ объявление переменной считается оператором. Поэтому вы должны поставить после объявления точку с запятой.

Фрагмент следующей программы объявляет три переменные, используя типы int, float и long:

#include <iostream.h>

void main(void)

{
   int test_score;
   float salary;
   long distance_to_mars;
}

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

float salary, income_tax, retirement_fund;

Изучение переменных

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

int age;

Смысловые имена переменных

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

int х, у, z;

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

int student_age, test_score, grade;

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

float MonthlySalary, IncomeTax;

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

При создании имен переменных необходимо знать, что в C++ слова, перечисленные в табл. 4.2, резервируются в качестве ключевых слов, имеющих специальное значение для компилятора. Вы не имеете права использовать ключевые слова C++ в качестве имен переменных.

Таблица 4.2. Ключевые слова C++.

Почему ваши программы используют переменные

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

ПРИСВАИВАНИЕ ЗНАЧЕНИЯ ПЕРЕМЕННОЙ

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

age = 32;
salary = 25000.75;
distance_to_the_moon = 238857;

Замечание: Значения, присваиваемые переменным, не должны содержать запятые (например, 25,000.75 и 238,857) *. Если вы включаете запятые, компилятор C++ будет генерировать и выводить сообщения о синтаксических ошибках.

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

* Американская запись чисел предполагает отделение каждых трех разрядов целой части числа запятой. - Прим. ред.

#include <iostream.h>

void main(void)

{
   int age ;
   float salary;
   long distance_to_the_moon;

age = 32;
   salary = 25000.75;
   distance_to_the_moon = 238857;
}

Присваивание значения при объявлении

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

int age = 32;
float salary = 25000.75;
long distance_to_the_moon = 238857;

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

Присваивание значений переменным

При выполнении программы переменные хранят информацию. Для записи значения в переменную программы должны использовать оператор присваивания C++ (знак равно). Следующая строка использует оператор присваивания для записи значения 4 в переменную lesson:

lesson = 4;

Для упрощения этого процесса в C++ можно также присвоить значение переменной при ее объявлении:

int lesson = 4;

ИСПОЛЬЗОВАНИЕ ЗНАЧЕНИЯ ПЕРЕМЕННОЙ

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

#include <iostream.h>

void main (void)

{
   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++ использует точку с запятой для указания конца оператора. Если вам необходимо перенести строку, постарайтесь не делать этого в середине символьной строки (внутри двойных кавычек), используйте дополнительный отступ для перенесенной части строки, как показано выше.

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

С:\> SHOWVARS <ENTER>

Служащему 32 года (лет)

Оклад служащего составляет $25000.75

От земли до луны 238857 миль

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

ПРЕВЫШЕНИЕ ДИАПАЗОНА ЗНАЧЕНИЙ ПЕРЕМЕННОЙ

Как вы уже знаете, тип переменной определяет набор значений, которые переменная может хранить. Например, переменная типа int может хранить значения в диапазоне от -32768 до 32767. Если вы присваиваете переменной значение, которое находится вне этого диапазона, возникает ошибка переполнения. Например, следующая программа OVERFLOW.CPP иллюстрирует, как превышение диапазона значений переменной приводит к ошибке. Как видите, программа присваивает значения, которые находятся вне диапазона для переменной каждого типа:

#include <iostream.h>

void main(void)

{
   int positive = 40000;
   long big_positive = 4000000000;
   char little_positive = 210;
   cout << "сейчасpositive содержит" << positive << endl;
   cout << "сейчасbig_positive содержит" << big_positive << endl;
   cout << "сейчасlittle_poaitive содержит" << little_positive << endl;
}

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

сейчас positive содержит -25536

сейчас big_positive содержит -294967296

сейчас little_positive содержит Т

Как видите, программа присваивает переменным типа int, long и char значения, которые находятся вне диапазона хранения каждого типа, поэтому возникает ошибка переполнения. При работе с переменными вам необходимо помнить диапазон значений, которые может хранить переменная каждого типа. Ошибки переполнения плохо уловимы, и поэтому их трудно определить и исправить. Обратите внимание на значение, которое программа выводит для переменной little_positive. Поскольку это переменная типа char, выходной поток cout пытается вывести ее значение в символьном виде. В этом случае выведенное значение соответствует второй половине таблицы ASCII со значением 210.

ПРЕДСТАВЛЕНИЕ О ТОЧНОСТИ

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

Следующая программа PRECISE. CPP присваивает значение чуть меньше 0.5 переменным типа float и double. К сожалению, поскольку компьютер обладает ограниченной способностью в представлении чисел, переменные реально содержат не присваиваемые им значения, а число 0.5:

#include <iostream.h>

void main(void)

{
   float f_not_half = 0.49999990;
   double d_not_half = 0.49999990;
   cout << "Значениетипаfloat 0.49999990 равно" << f_not_half << endl;
   cout << "Значениетипаdouble 0.49999990 равно" << d_not_half << endl;
}

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

Значение типа float 0.49999990 равно 0.5

Значение типа double 0.49999990 равно 0.5

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

ИСПОЛЬЗОВАНИЕ КОММЕНТАРИЕВ ДЛЯ УЛУЧШЕНИЯ ЧТЕНИЯ ВАШИХ ПРОГРАММ

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

3.      Использование понятных по смыслу имен переменных, описывающих их применение.

4.      Использование подходящих отступов и выравнивания (см. урок 7).

5.      Использование пустых строк для разделения несвязанных операторов.

6.      Использование комментариев, которые объясняют работу программы.

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

// Это комментарий

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

// Программа: BUDGET.CPP
// Программист: Kris Jamsa
// дата создания: 1-10-96
//
// Цель: Ежемесячная информация о бюджете.

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

distance_to_the_moon = 238857; // Расстояние в милях

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

аде =32; // Присвоить 32 переменной age
salary = 25000.75; // Присвоить 25000.75 переменной salary

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

Добавление комментариев в ваши программы

При создании программ включайте комментарии, которые объясняют работу программы. Если другим программистам понадобится изменить вашу программу, они смогут воспользоваться комментариями, чтобы понять поведение программы. Обычно в программах на C++ комментарий начинается с двойного слеша:

// Это комментарий C++

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

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

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

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

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

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

3.      Имена переменных должны начинаться с буквы или символа подчеркивания.

4.      В C++ буквы верхнего и нижнего регистров считаются разными.

5.      Тип переменной определяет тип значения, которое переменная может содержать. Общими типами переменных являются char, int, float и long.

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

Урок 5. Выполнение простых операций

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

1.      Для выполнения математических операций используйте в своих программах арифметические операторы C++.

2.      Чтобы гарантировать последовательность операций, C++ назначает приоритет каждому оператору.

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

4.  Многие программы на C++ прибавляют или вычитают единицу, используя операции увеличения (++) или уменьшения (--).

После того как вы научитесь распознавать разные арифметические операторы C++, вы поймете, что выполнять математические операции очень легко!

ОСНОВНЫЕ МАТЕМАТИЧЕСКИЕ ОПЕРАЦИИ

Независимо от назначения большинство ваших программ на C++ будут складывать, вычитать, умножать или делить. Вы узнаете, что ваши программы могут выполнять арифметические операции с константами (например, 3*5) или с переменными (например, payment — total). Таблица 5.1 перечисляет основные математические операции C++:

Таблица 5. 1. Основные математические операции С++

Следующая программа SHOWMATH.CPP использует cout для вывода реультата нескольких простых арифметических операций:

#include <iostream.h>

void main(void)

{
   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;
}

Посмотрите внимательно на операторы программы. Обратите внимание, что каждое выражение сначала появляется в кавычках, которые обеспечивают вывод символов (например, 5 + 7 =) на экран. Затем программа выводит результат операции и символ новой строки. Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:

С:\> SHOWMATH <ENTER>

5 + 7 = 12

12 - 7 = 5

1.2345 * 2 = 2.469

15 / 3 = 5

В данном случае программа выполняла арифметические операции, используя только постоянные значения. Следующая программа MATHVARS.CPP выполняет арифметические операции, используя переменные:

#include <iostream.h>

void main(void)

{
   float cost =15.50; // Стоимость покупки
   float sales_tax = 0.06; // Налог на продажу 6%
   float amount_paid = 20.00; // Деньги покупателя
   float tax, change, total; // Налог на продажу, сдача покупателю и общий счет
   tax = cost * sales_tax;
   total = cost + tax;
   change = amount_paid - total;
   cout << "Стоимость покупки: $" << cost << "\tHaлor: $" << tax << "\tОбщий счет: $" << total << endl;
   cout << "Сдача покупателю: $" << change << endl;
}

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

С:\> MATHVARS <ENTER>

Стоимость покупки: $15.5 Налог: $0.93 Общий счет: $16.43

Сдача покупателю: $3.57

УВЕЛИЧЕНИЕ ЗНАЧЕНИЯ ПЕРЕМЕННОЙ НА 1

Обычной операцией, которую вы будете выполнять при программировании, является прибавление 1 к значению целой переменной. Например, предположим, что ваша программа использует переменную с именем count, чтобы сохранить данные о количестве напечатанных файлов. Каждый раз, когда программа печатает файл, 1 будет добавляться к текущему значению count. Используя оператор присваивания C++, ваша программа может увеличивать значение count, как показано ниже:

count = count + 1;

В данном случае программа сначала выбирает значение count, а затем добавляет к нему единицу. Далее программа записывает результат сложения обратно в переменную count. Следующая программа INTCOUNT.CPP использует оператор присваивания для увеличения переменной count (которая первоначально содержит значение 1000) на единицу (присваивая переменной результат 1001):

#include <iostream.h>

void main(void)

{
   int count = 1000;
   cout << "начальноезначениеcount равно" << count << endl;
   count = count + 1;
   cout << "конечноезначениеcount равно" << count << endl;
}

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

С:\> INCCOUNT <ENTER>

начальное значение count равно 1000

конечное значение count равно 1001

Так как увеличение значения переменной представляет собой обычную операцию в программах, в C++ есть операция увеличения — двойной знак плюс (++). Операция увеличения обеспечивает быстрый способ прибавления единицы к значению переменной. Следующие операторы, например, увеличивают значение переменной count на 1:

count = count + 1; count++;

Следующая программа INC_OP.CPP использует операцию увеличения для наращивания значения переменной count на 1:

#include <iostream.h>

void main(void)

{
   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;

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

#include <iostream.h>

void main(void)

{
   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;
}

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

С:\> PRE_POST <ENTER>

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(void)

{
   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;
}

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

С:\> DECCOUNT <ENTER”

small_count равно0

small_count-- производит 0

конечное значение small_count равно -1

big_count равно1000

—big_count производит999

конечное значение big_count равно 999

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

ДРУГИЕ ОПЕРАТОРЫ С++

В этом уроке описаны обычные арифметические операции C++, а также операции увеличения и уменьшения. В программах на 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++.

Управление порядком, в котором 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;

СЛЕДИТЕ ЗА ОШИБКАМИ ПЕРЕПОЛНЕНИЯ ПРИ АРИФМЕТИЧЕСКИХ ОПЕРАЦИЯХ

Из урока 4 вы узнали, что, если вы присваиваете переменной значение, которое не входит в диапазон значений для данного типа переменной, возникает ошибка переполнения. При выполнении арифметических операций необходимо помнить о возможности возникновения ошибок переполнения. Например, следующая программа MATHOVER.CPP умножает 200 на 300 и присваивает результат переменной типа int. Однако, поскольку результат умножения (60000) превышает наибольшее возможное значение для типа int (32767), возникает ошибка переполнения:

#include <iostream.h>

void main(void)

{
   int result;
   result = 200 * 300;
   cout << "200 * 300 = " << result << endl;
}

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

С:\> MATHOVER <ENTER>

200 * 300 = -5536

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

В данном уроке вы изучали обычные арифметические операции и операции приращения C++. Чтобы программы корректно выполняли арифметические вычисления, C++ назначает каждой операции приоритет, который управляет порядком выполнения операций. Из урока 6 вы узнаете, как использовать входной поток с именем cin для выполнения операций ввода с клавиатуры. До изучения урока 6 убедитесь, что вы освоили следующее:

1.  C++ использует операторы +,- , * и / для сложения, вычитания, умножения и деления.

2.  C++ обеспечивает префиксные (до) и постфиксные (после) операции увеличения, которые прибавляют единицу к значению переменной.

3.  C++ обеспечивает префиксную (до) и постфиксную (после) операции уменьшения, которые вычитают единицу из значения переменной.

4.  Префиксные (до) операции указывают C++ сначала увеличить (или уменьшить) значение переменной, а затем использовать это значение.

5.  Постфиксные (после) операции указывают C++ сначала использовать значение переменной, а затем увеличить (или уменьшить) его.

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

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

Урок 6. Чтение ввода с клавиатуры

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

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

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

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

Как вы уже знаете, если ваши программы используют выходной поток cout, они помещают данные в поток с помощью оператора вставки (<<). Подобным образом, если ваши программы применяют cin для чтения ввода с клавиатуры, они будут использовать оператор извлечения (>>).

ПЕРВОЕ ЗНАКОМСТВО С cin

Точно так же как выходной поток cout позволяет вашим программам записать вывод на экран, входной поток cin позволяет программам читать ввод с клавиатуры. Когда программы используют cin для чтения ввода с клавиатуры, они должны указать переменную, в которую cin поместит данные. Следующая программа FIRSTCIN.CPP использует cin для чтения числа, введенного с клавиатуры. Программа присваивает введенное число переменной с именем number, а затем выводит значение переменной, используя выходной поток cout:

#include <iostream.h>

void main(void)

{
   int number; II Число, читаемоесклавиатуры
   cout << "ВведитевашелюбимоечислоинажмитеEnter: ";
   cin >> number;
   cout << "Вашелюбимоечислоравно" << number << endl;
}

Когда вы откомпилируете и запустите эту программу, на вашем экране появится сообщение, предлагающее вам ввести ваше любимое число. Если вы введете число и нажмете ENTER, программа присвоит ввод переменной number. Затем, используя cout, программа выведет сообщение, отображающее ваше любимое число.

Следующая программа TWONBRS.CPP запрашивает у вас два числа. Программа присваивает числа переменным first и second. Затем программа выводит числа, используя cout:

#include <iostream.h>

void main(void)

{
   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

Для чтения ввода с клавиатуры программы могут использовать входной поток cin. При использовании cin вы должны указать переменную, в которую cin помещает данные. Затем используйте оператор извлечения (>>) для направления данных, как показано ниже:

cin >> some_variable;

Оператор извлечения называется так, потому что он извлекает (удаляет) данные из входного потока, присваивая значение указанной переменной.

Следите за ошибками переполнения

Если ваши программы выполняют ввод с использованием cin, остерегайтесь возможных ошибок, возникающих при вводе пользователем неверного числа. Например, запустите программу FIRSTCIN, которую вы только что создали. Когда программа запросит вас ввести ваше любимое число, введите число 1000000 и нажмите ENTER. При этом программа не сможет отобразить число 1000000 в качестве введенного значения. Вместо этого возникнет ошибка переполнения, так как 1000000 превышает наибольшее значение, которое может хранить тип int.

Если вы внимательно рассмотрите программу FIRSTCIN. CPP, то обратите внимание, что cin присваивает введенное число переменной типа int. Как вы узнали из урока 4, переменные типа int могут хранить значения только в диапазоне от -32768 до 32767. Поскольку переменная типа int не может вместить значение 1000000, возникает ошибка. Запустите программу еще несколько раз, вводя отрицательные и положительные числа. Обратите внимание на ошибки, которые возникают, если вы выходите за допустимые пределы значений для той переменной, в которую cin помещает ввод.

Следите за ошибками несовпадения типов

Как уже обсуждалось, программа FIRSTCIN.CPP предполагает, что пользователь вводит значение в диапазоне от -32768 до 32767. Если вместо ввода числа вне этого диапазона, пользователь вводит буквы или другие символы, то возникает другая ошибка — ошибка несовпадения типов. Другими словами, программа ожидала значение одного типа (int), а пользователь ввел значение другого типа (char). Для примера запустите программу второй раз. Когда программа запросит число, введите буквы АВС. Как и раньше, возникнет ошибка, поскольку программа ожидает целое число, а не буквы.

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

Чтение символьных данных

Обе предыдущие программы использовали cin для чтения целых чисел в переменные типа int. Следующая программа CIN_CHAR.CPP использует входной поток cin для чтения символов с клавиатуры. Как видите, программа читает символ в переменную типа char.

#include <iostream.h>

void main(void)

{
   char letter;
   cout << "Введите любой символ и нажмите Enter: ";
   cin >> letter;
   cout << "Был введен символ " << letter << endl;
}

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

Чтение слов с клавиатуры

Во второй части данной книги вы научитесь сохранять слова или даже строки текста в одной переменной. Там же вы узнаете, как использовать входной поток cin для чтения слов и целых строк. А сейчас можете создать свою собственную простую программу, которая читает значения типа float или long. Например, следующая программа CIN_LONG.CPP использует cin для чтения значения типа long:

#include <iostream.h>

void main(void)

{
   long value;
   cout << "ВведитебольшоечислоинажмитеEnter: ";
   cin >> value;
   cout << "Быловведеночисло" << value << endl;
}

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

Перенаправление В/В и входной поток cin

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

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

В этом уроке вы научились использовать входной поток cin для выполнения ввода с клавиатуры. Как вы уже знаете, если ваши программы используют cin для чтения ввода с клавиатуры, вам следует указать переменные, которым cin присваивает вводимые значения. В уроке 7 вы научитесь использовать оператор C++ if, чтобы позволить программам принимать собственные решения. Однако перед тем, как приступить к уроку 7, убедитесь, что вы освоили следующие основные концепции:   

1.      C++ предоставляет входной поток cin, который ваши программы могут использовать для чтения ввода с клавиатуры.

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

3.      Чтобы направить ввод в переменную, вам следует использовать cin с оператором извлечения (>>).

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

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

Урок 7. Программа принимает решение

Как вы уже знаете, программа представляет собой последовательность инструкций, выполняемых компьютером для реализации определенных задач. Все созданные вами до сих пор простые программы на C++ выполняли операторы по порядку, начиная с первого до конца программы. По мере усложнения программ вам потребуется, чтобы выполнялся один набор операторов, если определенное условие соблюдается, и другой набор, если условие не соблюдается. Другими словами, вам потребуется, чтобы ваши программы приняли решение и соответственно отреагировали. В этом уроке описывается оператор C++ if, который будет использоваться вашей программой для принятия подобных решений. К концу данного урока вы освоите следующие основные концепции:

1.      Программы на C++ используют операции сравнения, чтобы определить, равны ли два значения или одно значение больше или меньше другого.

2.      Для принятия решений используется оператор C++ if.

3.      Операторы C++ могут быть простыми (одна операция) или составными (несколько операций, сгруппированных внутри правой и левой фигурных скобок {}).

4.      Ваши программы используют оператор C++ if-else для выполнения одного набора операторов, если определенное условие соблюдается, и другого набора операторов, если условие не соблюдается.

5.  Комбинируя несколько операторов if-else, программы могут проверять несколько условий.

6.  Используя логические операторы C++ И и ИЛИ, ваши программы могут проверить несколько условий, например: Есть ли у пользователя собака И долматин ли это ?

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

СРАВНЕНИЕ ДВУХ ЗНАЧЕНИЙ

Когда ваши программы принимают решение, они обычно выполняют некоторый вид проверки. Например, одна программа может проверять, равны ли тестовые очки студента 100, а вторая программа — составляет ли стоимость покупки больше $50.00. Для выполнения подобных проверок ваши программы будут использовать операции сравнения C++, перечисленные в табл. 7.1. Операции сравнения позволяют проверять, каким образом одно значение соотносится с другим. Другими словами, используя операции сравнения, программы могут проверить, больше одно значение, меньше или равно другому.

Таблица 7.1. Операции сравнения C++.

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

ЗНАКОМСТВО С ОПЕРАТОРОМ if

Оператор C++ if позволяет вашим программам осуществлять проверку и затем на основании этой проверки выполнять операторы. Формат оператора if следующий:

if (условие_выполняется) оператор;

Обычно оператор if выполняет проверку, используя операцию сравнения C++. Если результат проверки является истиной, if выполняет оператор, который следует за ним. Следующая программа FIRST_IF.CPP использует оператор if для сравнения значения переменной test_score со значением 90. Если набранные тестовые очки больше или равны 90, программа выведет сообщение пользователю, что он получил А. В противном случае, если значение меньше 90, программа просто завершается:

#include <iostream.h>

void main(void)

{
   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;
} //----------------->Составной оператор

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

#include <iostream.h>

void main(void)

{
   int test_score = 95;

if (test_score >= 90)

{
   cout << "Поздравляем, вы получили А!" << endl;
   cout << "Ваши тестовые очки были " << test_score << endl;
}

}

Использование простых и составных операторов

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

if (age >= 21)

{
   cout << "Все на выборы!" << endl;
   cout << "Это то, что вам надо!" << endl;
}

ОПЕРАТОР else

Две предыдущие программы использовали оператор if, чтобы определить, больше тестовые очки или равны 90. Если условие было истинным, программы выводили сообщение на экран. В противном случае, т. е. если тестовые очки были меньше 90, программы не выводили сообщение, они просто завершались. В большинстве случаев вашим программам потребуется указать один набор операторов, выполняющийся, если условие истинно, и второй набор, выполняющийся, если условие ложно. Для указания операторов, которые должны выполняться, когда условие ложно, ваши программы должны использовать оператор else. Ниже приведен формат оператора else:

if (условие_истинно)
   оператор;
else
   оператор;

Следующая программа IF_ELSE.CPP использует оператор if, чтобы проверить, больше тестовые очки или равны 90. Если условие истинно, программа выводит поздравление. Если условие ложно, программа сообщает, что студент должен работать усерднее:

#include <iostream.h>

void main(void)

{
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;
       }
}

Как и ранее, найдите время поэкспериментировать с этой программой, изменяя значения переменной test_score так, чтобы оно было меньше или больше 90. Следующая программа GETSCORE.CPP использует входной поток cin для ввода тестовых очков пользователем. Затем программа сравнивает тестовые очки со значением 90, выводя соответствующее сообщение:

#include <iostream.h>

void main(void)

{
   int test_score;
   cout << "ВведитетестовыеочкиинажмитеEnter: ";
   cin >> test_score;
   if (test_score >= 90)
      {
         cout << "Поздравляем, выполучилиА!" << endl;
         cout << "Ваши тестовые очки были " << test_score << endl;
      }
   else
      {
         cout << "Вы должны работать усерднее!" << endl;
         cout << "Вы потеряли " << 100 - test_score << " очков " << endl;
      }
}

Откомпилируйте и запустите эту программу. Вы увидите, что при комбинации операций ввода с условной обработкой ваши программы станут более совершенными.

Представление об if-else

По мере усложнения ваши программы будут проверять разные условия и выполнять один набор операторов, если условие истинно, и другой набор, если условие ложно. Для выполнения такой условной обработки программы используют операторы if-else, как показано ниже:

if (условие_истинно)
   оператор;
else
   оператор;

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

if (условие_истинно)

{
      первый_оператор_для_истины;
      второй_оператор_для_истины;
   }
else
   {
      первый_оператор_для_лжи;
      второй_оператор_для_лжи;
   }

ИСПОЛЬЗОВАНИЕ ОТСТУПОВ ДЛЯ УЛУЧШЕНИЯ УДОБОЧИТАЕМОСТИ ВАШЕЙ ПРОГРАММЫ

Рассматривая программы, представленные в этой главе, вы увидите, что в них применяются отступы перед операторами, которые следуют за if, else или левой скобкой. Сдвигая подобным образом свои операторы на одну или две позиции, вы упрощаете процесс чтения ваших программ, выделяя связанные группы операторов, как показано ниже:

if (test_score >= 90)

{
        cout << "Поздравляем, вы получили А!" << endl;
        cout << "Ваши тестовые очки были " << test_score << endl;
    }
else
   {
        cout << "Вы должны работать усерднее!" << endl;
        cout << "Вы потеряли " << 100 - test_score << " очков " << endl;
   }

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

ПРОВЕРКА ДВУХ ИЛИ БОЛЕЕ УСЛОВИЙ

Как вы уже знаете, оператор 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(void)

{
   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;
}

Экспериментируйте с этой программой, присваивая обоим переменным значение 1 или 0, а затем одной 1, а другой 0 и наоборот. Как видите, проверить два условия очень легко, используя логические операции И и ИЛИ.

Использование операции НЕ в 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(void)

{
   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;
}

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

Использование логических операций C++

Если вы указываете условия в программах, то иногда эти условия будут состоять из нескольких частей. Например, ваша программа может проверять, имеет ли служащий почасовую оплату и работал ли он более 40 часов на этой неделе. Если для истинности условия каждая из двух его частей должна быть истиной, вам следует использовать операцию C++ И (&&). При ,использовании операции И группируйте каждое условие внутри круглых скобок, а затем оба условия заключите в еще одну пару круглых скобок, как показано ниже:

if ((employee_pay == hourly) && (employee_hours > 40))
    оператор;

Когда необходимо, чтобы условие было истинным, если только одна из его частей истинна, вам следует использовать операцию C++ ИЛИ (|[). Например, следующее условие проверяет, есть ли у пользователя машина или мотоцикл:

if ((vehicle == car) II (vehicle == motorcycle))
    оператор;

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

Операции C++ И, ИЛИ и НЕ представляют собой логические операции.

ОБРАБОТКА НЕСКОЛЬКИХ УСЛОВИЙ

Программы, представленные в этом уроке, использовали if и else, чтобы указать один набор операторов, который программе следует выполнить, если условие истинно, и другой набор операторов, выполняемых, если условие ложно. Однако в некоторых случаях программам потребуется проверить несколько разных условий. Предположим, например, что вашей программе необходимо определить тестовые очки студента. Для этого программа должна проверить, больше тестовые очки или равны 90, 80, 70, 60 и т. д. Следующая программа SHOWGRAD.CPP использует для этого серию операторов if-else:

#include <iostream.h>

void main(void)

{
   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(void)

{
   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++ рассматриваются как истинные).

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

Из этого урока вы узнали, как использовать оператор C++ if для выполнения условной обработки, которая позволяет вашим программам принимать собственные решения. Как вы знаете, программы могут использовать оператор if, чтобы выполнить один набор операторов, когда условие истинно, и else для указания операторов, выполняющихся программой, если условие ложно. Из урока 8 вы узнаете, как использовать итеративные операторы C++ для повторения операторов указанное число раз или до тех пор, пока выполняется определенное условие. Например, вы можете повторять один и тот же оператор 100 раз, чтобы прибавить 100 студентам тестовые очки. Однако до изучения урока 8 убедитесь, что вы освоили следующие основные концепции:   

1.      Операции сравнения C++ позволяют вашим программам проверять, равны ли два значения или нет, или одно значение больше или меньше другого.

2.      Оператор C++ if позволяет программе проверять условия и выполнять один или несколько операторов, если условие истинно.

3.      Оператор C++ else позволяет указать один или несколько операторов, которые выполняются, если условие, проверяемое с помощью оператора if, является ложным.

4.      C++ представляет истину, используя любое ненулевое значение, а ложь как 0.

5.      Логические операции C++ И (&&) и ИЛИ (||) позволяют вашим программам проверять несколько условий.

6.      Логическая операция НЕ (!) позволяет программам проверять условие на неистинность.

7.      Если в операторе if или else нужно выполнить несколько операторов, то такие операторы следует расположить внутри левой и правой фигурных скобок {}.

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

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

10.  Когда программа встречает в операторе switch вариант (case), соответствующий условию, то все последующие варианты рассматриваются как удовлетворяющие условию. Используя оператор break, вы можете указать C++ прервать оператор switch и продолжить выполнение программы с первого оператора, который следует за switch.

Урок 8. Повторение одного или нескольких операторов

Из урока 7 вы узнали, как использовать в ваших программах оператор C++ if для принятия решений. С подобным принятием решений тесно связана способность повторять одну или несколько инструкций определенное число раз или до достижения некоторого условия. В этом уроке вы будете использовать итеративные конструкции C++ для повторения одного или нескольких операторов. К концу данного урока вы освоите следующие основные концепции:

1.  Для повторения операторов определенное число раз ваши программы используют оператор C++ for.

2.  С помощью оператора C++ while программы повторяют операторы до тех пор, пока указанное условие истинно.

3.  Оператор C++ do while позволяет программам выполнять операторы по крайней мере один раз, а затем, возможно, повторять операторы, основываясь на определенном условии.

Возможность повторять операторы очень важна в программировании. Экспериментируйте с программами, представленными в этом уроке. К концу урока вы сможете значительно усовершенствовать свои возможности программирования на 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(void)

{
   int count;
   for (count = 1; count <=100; count++) cout << count <<' ';
}

Как видите, оператор for инициализирует переменную count значением 1. Затем цикл проверяет, меньше ли значение переменной count или равно 100. Если это так, цикл for выполняет соответствующий оператор и затем увеличивает count, повторяя проверку. Экспериментируйте с этой программой, изменяя значение 100 на 10, 20 и даже 5000.

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

#include <iostream.h>

void main(void)

{
   int count;
   int ending_value;
   cout << "ВведитеконечноезначениеинажмитеEnter: ";
   cin >> ending_value;
   for (count = 0; count <= ending_value; count++)
     cout << count << ' ';
}

Экспериментируйте с этой программой, вводя разные числа, например 10, 1 и даже 0. Если вы вводите значение 0 или 1, цикл for никогда не выполняется, потому что условие count <= ending_value сразу же ложно. Помните, если вы введете значение вне диапазона значений, которые может хранить переменная типа int, возникнет ошибка переполнения. Например, запустите программу и введите значение 50000. Поскольку это значение превышает наибольшее возможное для переменной типа int, то переполнение приводит к отрицательному значению, которое предотвращает выполнение цикла.

Циклы for C++ поддерживают составные операторы

Из урока 7 вы узнали, что если программы выполняют несколько операторов внутри if или else, то такие операторы следует сгруппировать внутри левой и правой фигурных скобок. Это же относится и к нескольким операторам в цикле for. Следующая программа ADD1_100.CPP зацикливает числа от 1 до 100, выводя и добавляя каждое число в общий итог:

#include <iostream.h>

void main(void)

{
   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(void)

{
   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(void)

{
   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

Повторение цикла определенное число раз

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

for (инициализация; проверка; увеличение)
    оператор;

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

ВЗГЛЯД НА ЦИКЛ while

Как вы только что узнали, цикл C++ for позволяет вашим программам повторять один или несколько операторов определенное количество раз. Однако в некоторых случаях программе необходимо повторять операторы, пока удовлетворяется (истинно) некоторое условие. Например, в следующих уроках вы узнаете, как читать содержимое файла. Такие программы могли бы повторять цикл, пока не встретится конец файла. В ситуациях, когда программам необходимо выполнять цикл, пока удовлетворяется некоторое условие (но не обязательно определенное количество раз), ваши программы могут использовать оператор C++ while. Общий формат оператора while выглядит так:

while (условие_верно)
    оператор;

Если ваша программа встречает оператор while, она проверяет заданное условие. Если условие истинно, программа выполняет операторы цикла while. После выполнения последнего оператора в цикле, цикл while опять проверяет условие. Если условие все еще истинно, повторяются операторы цикла и повторяется данный процесс. Когда условие, наконец, становится ложным, цикл завершается и программа продолжает свое выполнение с первого оператора, следующего за циклом. Следующая программа GET_YN.CPP просит вас ввести Д для да или Н для нет. Затем программа использует цикл while для чтения символов с клавиатуры, пока пользователь не введет Д или Н. Если пользователь вводит значение, отличное от Д или Н, программа сигналит встроенным динамиком, записывая символ сигнала '\а' в выходной поток cout :

#include <iostream.h>

void main(void)

{
   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 в значение истина и цикл завершается. Как только ваши программы начнут работать с файлами, вы регулярно будете использовать цикл while.

Повторение цикла до выполнения заданного условия

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

while (условие)
   оператор;

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

ВЫПОЛНЕНИЕ ОПЕРАТОРОВ ПО КРАЙНЕЙ МЕРЕ ОДИН РАЗ

Как вы уже знаете, цикл C++ while позволяет вашим программам повторять набор операторов, пока данное условие удовлетворяется. Когда программа встречает оператор while, она сначала оценивает заданное условие. Если условие истинно, программа входит в цикл. Если условие ложно, операторы цикла while никогда не выполняются. В зависимости от назначения ваших программ, возможны ситуации, когда некоторый набор операторов должен выполняться по крайней мере один раз, а затем выполнение, основываясь на некотором условии, может повторяться. В подобном случае ваши программы могут использовать цикл do while:

do

{
   операторы;
}

while (условие_истинно);

Если программа встречает цикл do while, она входит в цикл и запускает выполнение операторов, содержащихся в цикле. Затем программа оценивает заданное условие. Если условие истинно, программа возвращается к началу цикла:

do <----------------------------------------

{                                                       |
   операторы;                                   |
}                                                       |

while (условие_истинно); ----------

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

Повторение операторов, если условие истинно

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

do {
   оператор;
} while (условие);

Когда программа встречает оператор do while, она сразу же выполняет операторы, содержащиеся в цикле. Затем программа исследует условие цикла. Если условие истинно, программа повторяет операторы цикла и процесс продолжается. Если условие цикла становится ложным, программа продолжает свое выполнение с первого оператора, следующего за оператором do while.

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

Итеративная обработка представляет собой способность программы повторять один или несколько операторов. В этом уроке были описаны итеративные (или циклические) операторы C++. Как вы уже знаете, оператор for позволяет вашим программам повторять один или несколько операторов заданное число раз. Используя оператор while, программы повторяют операторы до тех пор, пока указанное условие истинно. Наконец, с помощью оператора do while программы выполняют операторы, по крайней мере один раз, повторяя их, если заданное условие истинно. Из урока 9 вы узнаете, как разделить программы на небольшие легко управляемые части, называемые функциями. Однако до изучения урока 9 убедитесь, что освоили следующее:

1.      Оператор C++ for позволяет вашим программам повторять один или более операторов заданное число раз.

2.      Оператор for состоит из четырех частей: инициализации, проверяемого условия, операторов, которые повторяются, и приращения.

3.      Оператор for не обязывает вас увеличивать управляющую переменную цикла именно на 1 или использовать именно приращение.

4.      Цикл C++ while позволяет вашим программам повторять операторы, пока указанное условие истинно.

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

6.      Оператор C++ do while позволяет вашим программам выполнять один или несколько операторов, по крайней мере один раз, и воз можно, повторять их на основании заданного условия.

7.      Программы часто используют операторы do while для работы с меню

8.      Если проверяемые условия в циклах, while или do while становятся ложью, программа продолжает свое выполнение с первого оператора, следующего за циклом