Программирование. Принципы и практика использования C++ Исправленное издание

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

• Дать вам возможность поработать с интегрированной средой разработки программ.

• Дать вам почувствовать, как можно заставить компьютер делать то, что нужно.

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

2.1. Программы

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

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

В противоположность этому компьютер действительно глуп. Ему все необходимо точно и подробно описать. Вернемся к инструкциям “по коридору направо, вверх по лестнице, а потом налево”. Где находится коридор? Что такое коридор? Что значит “направо”? Что такое лестница? Как подняться по лестнице? По одной ступеньке? Через две ступеньки? Держась за перила? Что находится слева от меня? Когда это окажется слева от меня? Для того чтобы подробно описать инструкции для компьютера, необходим точно определенный язык, имеющий специфическую грамматику (естественный язык слишком слабо структурирован), а также хорошо определенный словарь для всех видов действий, которые мы хотим выполнить. Такой язык называется языком программирования, и язык программирования С++ — один из таких языков, разработанных для решения широкого круга задач.

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

2.2. Классическая первая программа

Приведем вариант классической первой программы. Она выводит на экран сообщение.

// Эта программа выводит на экран сообщение "Hello, World!"

#include "std_lib_facilities.h"

int main() // Программы на C++ начинаются с выполнения функции main

{

  cout << "Hello, World!\n"; // вывод "Hello, World!"

 return 0;

}

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

cout << "Hello, World!\n"; // вывод "Hello, World!"

Именно эта строка выводит сообщение на экран. Она печатает символы

Hello, World!

Hello,World!

В языке С++ строковые литералы выделяются двойными кавычками (

"

"Hello, Word!\n"

\n

cout

cout

<<

cout

Конец строки

// вывод "Hello, World!"

является комментарием. Все, что написано после символа

//

/

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

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

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

// Эта программа выводит на экран сообщение "Hello, World!"

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

Строка

#include "std_lib_facilities.h"

представляет собой директиву

#include

std_lib_facilities.h

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

std_lib_facilities.h

cout

<<

#include

.h

cout

Как компьютер находит точку, с которой начинается выполнение программы? Он просматривает функцию с именем

main

main

int main() // Программы на C++ начинаются с выполнения функции main

{

 cout << "Hello, World!\n"; // вывод "Hello, World!"

  return 0;

}

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

main

• Тип возвращаемого значения, в этой функции — тип

int

int

• Имя, в данном случае

main

• Список параметров, заключенный в круглые скобки (см. разделы 8.2 и 8.6); в данном случае список параметров пуст.

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

Отсюда следует, что минимальная программа на языке С++ выглядит так:

int main() { }

Пользы от этой программы мало, так как она ничего не делает. Тело функции

main

cout << "Hello, World!\n"; // вывод "Hello, World!"

return 0;

Во-первых, она выводит на экран строку

Hello, World!

0

main()

0

main()

Часть программы на языке С++, определяющая действие и не являющаяся директивой

#include

2.3. Компиляция

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

.cpp

hello_world.cpp

.h

std_lib_facilities.h

.obj

.o

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

#include

// пропущен заголовочный файл

int main()

{

 cout << "Hello, World!\n";

 return 0;

}

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

#include

#include "std_facilities.h"

int main()

{

 cout << "Hello, World!\n";

  return 0;

}

К сожалению, компилятор снова сообщает об ошибке, так как мы сделали опечатку в строке

std_lib_facilities.h

#include "std_lib_facilities.h

int main()

{

 cout << "Hello, World!\n;

 return 0;

}

В этом примере мы пропустили закрывающую двойную кавычку (

"

#include "std_lib_facilities.h"

integer main()

{

 cout << "Hello, World!\n";

  return 0;

}

Теперь мы вместо ключевого слова

int

integer

#include "std_lib_facilities.h"

int main()

{

  cout < "Hello, World!\n";

 return 0;

}

Здесь вместо символов

<<

<

#include "std_lib_facilities.h"

int main()

{

 cout << 'Hello, World!\n';

 return 0;

}

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

#include "std_lib_facilities.h"

int main()

{

 cout << "Hello, World!\n"

 return 0;

}

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

;

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

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

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

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

Итак, помните: компилятор — ваш друг; возможно, лучший друг.

2.4. Редактирование связей

Программа обычно состоит из нескольких отдельных частей, которые часто разрабатываются разными людьми. Например, программа “Hello, World!” состоит из части, которую написали вы, и частей стандартной библиотеки языка С++. Эти отдельные части (иногда называемые единицами трансляции) должны быть скомпилированы, а файлы с результирующим объектным кодом должны быть связаны вместе, образуя выполняемый файл. Программа, связывающая эти части в одно целое, называется (вполне ожидаемо) редактором связей.

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

Библиотека — это просто некий код (обычно написанный другими), который можно использовать с помощью директивы

#include

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

2.5. Среды программирования

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

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

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

В этой книге в качестве интегрированной среды программирования используется программа Visual C++ компании Microsoft. Если мы говорим просто “компилятор” или ссылаемся на какую-то часть интегрированной среды разработки, то это значит, что мы имеем в виду часть программы Visual C++. Однако вы можете использовать любую другую систему, обеспечивающую современную и стандартную реализацию языка С++. Все, что мы напишем, при очень небольшой модификации, остается справедливым для всех реализаций языка С++, и код будет работать на любом компьютере. В нашей работе мы обычно используем несколько разных реализаций.

Задание

До сих пор мы говорили о программировании, коде и инструментах (например, о компиляторах). Теперь нам необходимо выполнить программу. Это очень важный момент в изложении и в обучении программированию вообще. Именно с этого начинается усвоение практического опыта и овладение хорошим стилем программирования. Упражнения в этой главе предназначены для того, чтобы вы освоились с вашей интегрированной средой программирования. Запустив программу “Hello, World!” на выполнение, вы сделаете первый и главный шаг как программист.

Цель задания — закрепить ваши навыки программирования и помочь вам приобрести опыт работы со средами программирования. Как правило, задание представляет собой последовательность модификаций какой-нибудь простой программы, которая постепенно “вырастает” из совершенно тривиального кода в нечто полезное и реальное.

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

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

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

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

Итак, вот первое задание.

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

2. Введите в файл

hello_world.cpp

hello_world

#include "std_lib_facilities.h"

int main() // Программы на C++ начинаются с выполнения функции

 main

{

 cout << "Hello, World!\n"; // вывод строки"Hello, World!"

 keep_window_open();     // ожидание ввода символа

 return 0;

}

Вызов функции

keep_window_open()

keep_window_open()

std_lib_facilities.h.

std_lib_facilities.h

www.stroustrup.com/Programming.

#include

#include

#include

#include

#include

#include

using namespace std;

inline void keep_window_open() { char ch; cin>>ch; }

В этих строках стандартная библиотека используется непосредственно. Подробности этого кода изложены в главе 5 и разделе 8.7.

3. Скомпилируйте и выполните программу “Hello, World!”. Вполне вероятно, что у вас это сразу не получится. Очень редко первая попытка использовать новый язык программирования или новую среду разработки программ завершается успехом. Найдите источник проблем и устраните его! В этот момент целесообразно заручиться поддержкой более опытного специалиста, но перед этим следует убедиться, что вы сами сделали все, что могли.

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

keep_window_open()

Контрольные вопросы

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

1. Для чего предназначена программа “Hello, World!”?

2. Назовите четыре части функции.

3. Назовите функцию, которая должна существовать в каждой программе, написанной на языке С++.

4. Для чего предназначена строка

return 0

5. Для чего предназначен компилятор?

6. Для чего предназначена директива

#include

7. Что означает расширение

.h

8. Что делает редактор связей?

9. В чем заключается различие между исходным и объектным файлом?

10. Что такое интегрированная среда разработки и для чего она предназначена?

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

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

Термины

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

Упражнения

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

1. Измените программу так, чтобы она выводила две строки:

Hello, programming!

Here we go!

2. Используя приобретенные знания, напишите программу, содержащую инструкции, с помощью которых компьютер нашел бы ванную на верхнем этаже, о которой шла речь в разделе 2.1. Можете ли вы указать большее количество шагов, которые подразумевают люди, а компьютер — нет? Добавьте эти команды в ваш список. Это хороший способ научиться думать, как компьютер. Предупреждаем: для большинства людей “иди в ванную” — вполне понятная команда. Для людей, у которых нет собственного дома или ванной (например, для неандертальцев, каким-то образом попавших в гостиную), этот список может оказаться очень длинным. Пожалуйста, не делайте его больше страницы. Для удобства читателей можете изобразить схему вашего дома.

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

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

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

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

• Составьте словарь использованных терминов. (Что такое противень? Что такое предварительный разогрев? Что подразумевается под духовкой?)

• Теперь приготовьте несколько булочек и насладитесь результатом.

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

www.research.att.com/~bs/glossary.html.

Послесловие

Почему программа “Hello, World!” так важна? Ее цель — ознакомить вас с основными инструментами программирования. Мы стремились использовать для этого максимально простой пример.

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

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

char, int, double

string

3.1. Ввод

Программа “Hello, World!” просто записывает текст на экран. Она осуществляет вывод. Она ничего не считывает, т.е. не получает ввода от пользователя. Это довольно скучно. Реальные программы, как правило, производят результаты на основе каких-то данных, которые мы им даем, а не делают одно и то же каждый раз, когда мы их запускаем.

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

string

int

Например, на рисунке изображен объект типа

int

age

// считать и записать имя

#include "std_lib_facilities.h"

int main()

{

 cout << "Пожалуйста, введите ваше имя (затем нажмите 'enter'):\n";

 string first_name;  // first_name — это переменная типа string

 cin >> first_name;  // считываем символы в переменную first_name

 cout << "Hello, " << first_name << "!\n";

}

Директива

#include

main()

#include

main()

cout << "Пожалуйста, введите ваше имя (затем нажмите 'enter'):\n";

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

Первая строка функции

main()

string

first_name

string first_name; // first_name — это переменная типа string

Эта строка выделяет участок памяти для хранения строки символов и присваивает ему имя

first_name

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

Следующая строка считывает символы с устройства ввода (клавиатуры) в переменную:

cin >> first_name; // считываем символы в переменную first_name

Имя

cin

>>

Nicolas

Nicolas

first_name

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

Введя входную строку в переменную

first_name

cout << "Hello, " << first_name << "!\n";

Эта строка выводит на экран слово Hello за которым следует имя Nicolas (значение переменной

first_name

!

'\n'

Hello, Nicolas!

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

cout << "Hello, ";

cout << first_name;

cout << "!\n";

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

Обратите внимание на то, что мы заключили выражение

Hello

first_name

cout << "Имя " << " — " << first_name;

Здесь строка "

Имя

first_name

first_name

Nicolas

Имя — Nicolas

3.2. Переменные

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

int

string

int

123

string

Hello, World!\n

int

*

string

<=

string name = "Annemarie";

int number_of_steps = 39;

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

Мы не можем записывать в переменную значение неприемлемого типа.

string name2 = 39;  // ошибка: 39 — это не строка

int number_of_steps = "Annemarie"; // ошибка: "Annemarie"

                  // — не целое число

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

В языке С++ предусмотрен довольно широкий выбор типов (см. раздел A.8). Однако можно создавать прекрасные программы, обходясь лишь пятью из них.

int number_of_steps = 39;  // int — для целых чисел

double flying_time = 3.5;  // double — для чисел с плавающей точкой

char decimal_point = '.';  // char — для символов

string name = "Annemarie"; // string — для строк

bool tap_on = true;     // bool — для логических переменных

Ключевое слово

double

Обратите внимание на то, что каждый из этих типов имеет свой характерный способ записи.

39      // int: целое число

3.5     // double: число с плавающей точкой

'.'     // char: отдельный символ, заключенный в одинарные кавычки

"Annemarie" // string: набор символов, выделенный двойными кавычками

true     // bool: либо истина, либо ложь

Иначе говоря, последовательность цифр (например,

1234

2

976

1

@

x

1.234

0.12

.98

1234

Howdy!

Annemarie

3.3. Ввод и тип

Операция ввода

>>

// ввод имени и возраста

int main()

{

 cout << "Пожалуйста, введите свое имя и возраст \n";

 string first_name; // переменная типа string

 int age;      // переменная типа integer

 cin >> first_name; // считываем значение типа string

 cin >> age;     // считываем значение типа integer

 cout << "Hello, " << first_name << " (age " << age << ")\n";

}

Итак, если вы наберете на клавиатуре

Carlos 22

>>

Carlos

first_name

22

Hello, Carlos (age 22)

Почему вся строка

Carlos 22

first_name

>>

>>

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

22 Carlos

22

first_name

22

Carlos

22

(age

–96739

0

age

age

// ввод имени и возраста (2-я версия)

int main()

{

 cout << "Пожалуйста, введите свое имя и возраст \n";

 string first_name = "???";  // переменная типа string

                // ("???" означает, что "имя неизвестно")

 int age = –1;        // переменная типа int (–1 означает

                // "возраст неизвестен")

 cin >> first_name >> age;  // считываем строку, а затем целое число

 cout << "Hello, " << first_name << " (age " << age << ")\n";

}

Теперь ввод строки

22 Carlos

Hello, 22 (age –1)

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

<<

>>

age

int

first_name

Hello,

(age

\n

Ввод объекта типа

string

>>

>>

int main()

{

  cout << "Пожалуйста, введите свое имя и отчество\n";

  string first;

 string second;

 cin >> first >> second; // считываем две строки

 cout << "Hello, " << first << ' ' << second << '\n';

}

Здесь мы просто использовали оператор

>>

ПОПРОБУЙТЕ

Запустите программу “имя и возраст”. Измените ее так, чтобы она выводила возраст, измеренный месяцами: введите возраст, выраженный в годах, и умножьте это число на 12 (используя оператор

*

double

3.4. Операции и операторы

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

int count;

cin >> count;        // оператор >> считывает целое число в объект count

string name;

cin >> name;         // оператор >> считывает строку в переменную name

int c2 = count+2;      // оператор + складывает целые числа

string s2 = name + " Jr. "; // оператор + добавляет символы

int c3 = count–2;      // оператор – вычитает целые числа

string s3 = name – "Jr. ";  // ошибка: оператор – для строк не определен

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

int age = –100;

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

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

Рассмотрим пример, в котором фигурируют числа с плавающей точкой.

// простая программа, демонстрирующая работу операторов

int main()

{

 cout << "Пожалуйста, введите значение с плавающей точкой: ";

 double n;

 cin >> n;

 cout << "n == " << n

 << "\nn+1 == " << n+1

  << "\n три раза по n == " << 3*n

 << "\n два раза по n == " << n+n

  << "\nn в квадрате == " << n*n

  << "\n половина n == " << n/2

  << "\n корень квадратный из n == " << sqrt(n)

 << endl; // синоним перехода на новую строку ("end of line")

}

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

sqrt(n)

ПОПРОБУЙТЕ

Запустите эту небольшую программу. Затем измените ее так, чтобы считать значение типа

int

double

sqrt()

double

sqrt()

5/2

2

2.5

3

5%2

1

*

/

%

a

b

int

a/b*b+a%b==a

Для типа

string

// ввод имени и отчества

int main()

{

 cout << "Пожалуйста, введите свое имя и отчество \n";

 string first;

 string second;

 cin >> first >> second;       // считываем две строки

 string name = first + ' ' + second; // конкатенируем строки

 cout << "Hello, " << name << '\n';

}

Для строк оператор

+

s1

s2

string

s1+s2

s1

s2

s1

Hello

s2

World

s1+s2

HelloWorld

// ввод и сравнение имен

int main()

{

  cout << "Пожалуйста, введите два имени\n";

 string first;

 string second;

 cin >> first >> second;   // считываем две строки

 if (first == second) cout << " имена совпадают \n";

 if (first < second)

   cout << first << " по алфавиту предшествует " << second <<'\n';

  if (first > second)

    cout << first << " по алфавиту следует за " << second <<'\n';

}

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

if

3.5. Присваивание и инициализация

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

=

int a = 3; // начальное значение переменной a равно 3

a = 4; // переменная а принимает значение 4

    //("становится четверкой")

int b = a; // начальное значение переменной b является копией

      // значения переменной a (т.е. 4)

b = a+5; // переменная b принимает значение a+5 (т.е. 9)

a = a+7; // переменная a принимает значение a+7 (т.е. 11)

Последнее присваивание заслуживает внимания. Во-первых, оно ясно показывает, что знак “равно” не означает равенства, поскольку очевидно, что

а

а+7

a= a+7

1. Сначала получаем значение переменной

a

4

2. Затем добавляем к четверке семерку, получаем целое число

11

3. В заключение записываем значение

11

a

Эту операцию можно продемонстрировать также на примере строк.

string a = "alpha"; // начальное значение переменной a равно "alpha"

a = "beta"; // переменная a принимает значение "beta"

      // (становится равной "beta")

string b = a; // начальное значение переменной b является

        // копией значения переменной a (т.е. "beta")

b = a+"gamma"; // переменная b принимает значение a+"gamma"

         // (т.е. "betagamma")

a = a+"delta"; // переменная a принимает значение a+"delta"

         // (т.е. "betadelta")

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

• Инициализация (присваивание переменной ее начального значения).

• Присваивание (запись в переменную нового значения).

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

int y = 8;      // инициализация переменной y значением 8

x = 9;        // присваивание числа 9 переменной x

string t = "howdy!"; // инициализация переменной t значением "howdy!"

s = "G'day";     // присваивание переменной s значения "G’day" 

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

int

string

3.6. Составные операторы присваивания

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

++counter

означает

counter = counter + 1

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

7

9

2

a += 7; // означает a = a+7

b –= 9; // означает b = b–9

c *= 2; // означает c = c*2

В целом для любого бинарного оператора

oper

a oper= b

a= a oper b

+=

–=

*=

/=

%=

*=

/=

3.7. Имена

Мы даем своим переменным имена, чтобы запоминать их и ссылаться на них в других частях программы. Какие сущности могут иметь имена в языке С++? В программе на языке С++ имя начинается с буквы и содержит только буквы, цифры и символ подчеркивания. Приведем несколько примеров.

x

number_of_elements

Fourier_transform

z2

Polygon

Приведенные ниже слова не являются именами.

2x       // имя должно начинаться с буквы

time$to$market // символ $ — не буква, не цифра и не подчеркивание

Start menu   // пробел — не буква, не цифра и не подчеркивание

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

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

_foo

Имена чувствительны к регистру; иначе говоря, буквы, набранные в нижнем и верхнем регистрах, отличаются друг от друга, так что

x

X

#include "std_lib_facilities.h"

int Main()

{

 STRING s = "Прощай, жестокий мир!";

 cOut << S << '\n';

}

Как правило, использование имен, отличающихся лишь регистром, например

one

One

ПОПРОБУЙТЕ

Скомпилируйте программу “Прощай, жестокий мир!” и проверьте сообщения об ошибках. Смог ли компилятор выявить все ошибки? Какие проблемы обнаружил компилятор? Не запутался ли компилятор и не выявил ли он больше четырех ошибок? Удалите ошибки одну за другой, начиная с первой, и проанализируйте новые сообщения об ошибках (а затем уточните программу).

В языке С++ зарезервировано около семидесяти ключевых слов. Они перечислены в разделе A.3.1. Их нельзя использовать в качестве имен переменных, типов, функций и т.п. Рассмотрим пример.

int if = 7; // ошибка: "if" — это ключевое слово

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

string

int string = 7; // это порождает проблемы

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

x1

x2

s3

p7

mtbf

TLA

myw

NBV

Через несколько месяцев вы забудете, что все это значило. Короткие имена, такие как

x

i

x

i

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

partial_sum

element_count

stable_partition

А вот следующие имена нам кажутся слишком длинными:

the_number_of_elements

remaining_free_slots_in_symbol_table

Мы предпочитаем использовать в качестве разделителей слов в идентификаторе символы подчеркивания, например

element_count

elementCount

Element-Count

ALL_CAPITAL_LETTERS

Square

Graph

int

string

Int

String

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

Рассмотрим пример.

Name names nameS

foo f00 fl

f1 fI fi

Символы

0

o

O

1

l

I

3.8. Типы и объекты

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

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

• Объект — участок памяти, в котором хранится значение определенного типа.

• Значение — набор битов в памяти, интерпретируемый в соответствии с типом.

• Переменная — именованный объект.

• Объявление — инструкция, приписывающая объекту определенное имя.

• Определение — объявление, выделяющее память для объекта.

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

int

string

Interoperability

tokens: @#$%^&*

Old MacDonald had a farm

Представление объекта типа

string

int

string

double

string

x

1.2

s2

1

.

2

Все переменные типа

int

int

bool

char

double

bool

char

double

char

int

string

double

int

char

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

12.5

12.5

12.5

12.5

12.5

120

int

'x'

char

string

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

int (120)

char ('x')

Смысл двоичных чисел описан в разделе А.2.1.1.

3.9. Типовая безопасность

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

int main()

{

 double x;     // мы забыли проинициализировать переменную х:

           // ее значение не определено

 double y = x;   // значение переменной y не определено

 double z = 2.0+x; // смысл операции + и значение переменной z

           // не определены

}

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

х

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

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

vector

4.1. Вычисления

Все программы что-нибудь вычисляют; иначе говоря, они получают на вход какие-то данные и выводят какие-то результаты. Кроме того, само устройство, на котором выполняются программы, называется компьютером[5]. Эта точка зрения является правильной и обоснованной, пока мы придерживаемся широкой трактовки ввода и вывода.

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

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

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

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

Аббревиатура I/O означает ввод-вывод. В данном случае вывод из одной части программы является вводом в следующую часть. Эти части программы имеют доступ к данным, хранящимся в основной памяти, на постоянном устройстве хранения данных (например, на диске) или передающимся через сетевые соединения. Под частями программы мы подразумеваем сущности, такие как функция, вычисляющая результат на основе полученных аргументов (например, извлекающая корень квадратный из числа с плавающей точкой), функция, выполняющая действия над физическими объектами (например, рисующая линию на экране), или функция, модифицирующая некую таблицу в программе (например, добавляющая имя в таблицу клиентов).

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

Вычислением мы называем некое действие, создающее определенные результаты и основанное на определенных входных данных, например порождение результата (вывода), равного 49, на основе аргумента (ввода), равного 7, с помощью вычисления (функции) извлечения квадратного корня (см. раздел 4.5). Как курьезный факт, напомним, что до 1950-х годов компьютером[6] в США назывался человек, выполнявший вычисления, например бухгалтер, навигатор, физик. В настоящее время мы просто перепоручили большинство вычислений компьютерам (машинам), среди которых простейшими являются калькуляторы.

4.2. Цели и средства

Цель программиста — описать вычисления, причем это должно быть сделано следующим образом:

• правильно;

• просто;

• эффективно.

Пожалуйста, запомните порядок этих целей: неважно, как быстро работает ваша программа, если она выдает неправильные результаты. Аналогично, правильная и эффективная программа может оказаться настолько сложной, что ее придется отклонить или полностью переписать в виде новой версии. Помните, что полезные программы всегда должны допускать модификации, чтобы учитывать новые потребности, новые аппаратные устройства и т.д. Для этого программа — и любая ее часть — должны быть как можно более простыми. Например, предположим, что вы написали идеальную программу для обучения основам арифметики детей в вашей местной школе, но ее внутренняя структура является слишком запутанной. На каком языке вы собираетесь общаться с детьми? На английском? Английском и испанском? А не хотели бы вы, чтобы вашу программу использовали в Финляндии? А в Кувейте? Как изменить естественный язык, используемый для общения с детьми? Если программа имеет слишком запутанную структуру, то логически простая (но на практике практически всегда очень сложная) операция изменения естественного языка для общения с пользователями становится непреодолимой.

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

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

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

sort(b, e)

b

e

vector

map

• “Разделяй и властвуй”. Этот способ подразумевает разделение большой задачи на несколько меньших задач. Например, если требуется создать словарь, то работу можно разделить на три части: чтение, сортировка и вывод данных. Каждая из новых задач намного меньше исходной.

Чем это может помочь? Помимо всего прочего, программа, созданная из частей, обычно немного больше, чем программа, в которой все фрагменты оптимально согласованы друг с другом. Причина заключается в том, что мы плохо справляемся в большими задачами. Как правило, как в программировании, так и в жизни, — мы разбиваем их на меньшие части, полученные части разделяем на еще более мелкие, пока не получим достаточно простую задачу, которую легко понять и решить. Возвращаясь к программированию, легко понять, что программа, состоящая из 1000 строк, содержит намного больше ошибок, чем программа, состоящая из 100 строк, поэтому стоит разделить большую программу на части, размер которых меньше 100 строк. Для более крупных программ, скажем, длиной более 10 тыс. строк, применение абстракции и метода “разделяй и властвуй” является даже не пожеланием, а настоятельным требованием.

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

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

Обратите внимание на то, какое значение мы придаем структуре и организации программы: вы не сможете написать хорошую программу, просто перечислив множество инструкций. Почему мы упоминаем об этом сейчас? На текущем этапе вы (или, по крайней мере, многие читатели) слабо представляете себе, что такое программа, и лишь через несколько месяцев будете готовы написать программу, от которой может зависеть жизнь или благосостояние других людей. Мы упоминаем об этом, чтобы помочь вам правильно спланировать свое обучение. Существует большой соблазн набросать примерный план курса по программированию — похожего на изложенный в оставшейся части книги, — выделив темы, которые имеют очевидное полезное применение и проигнорировав более “тонкие” вопросы разработки программного обеспечения. Однако хорошие программисты и проектировщики систем знают (и это знание часто приобретается тяжелой ценой), что вопросы структуры лежат в основе хорошего программного обеспечения и пренебрежение ими порождает массу проблем. Не обеспечив хорошей структуры программы, вы, образно говоря, лепите ее из глины. Это вполне возможно, но таким образом никогда нельзя построить пятиэтажный дом (глина просто не выдержит). Если хотите построить не времянку, а солидное здание, то следует уделить внимание структуре и правильной организации кода, а не возвращаться к этим вопросам, совершив множество ошибок.

4.3. Выражения

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

a

3.14

"Norah"

Имена переменных также являются выражениями. Переменная — это объект, имеющий имя. Рассмотрим пример.

// вычисление площади:

int length = 20; // литеральное целое значение

         // (используется для инициализации переменной)

int width = 40;

int area = length*width; // умножение

Здесь литералы

20

40

length

width

length

length

length = 99; // присваиваем length значение 99

Здесь слово

length

length

length

length

lvalue

length

rvalue

length

length

length

Иначе говоря,

length

int

lvalue

length

rvalue

Комбинируя выражения с помощью операторов, таких как

+

*

int perimeter = (length+width)*2; // сложить и умножить

Без скобок это выражение пришлось бы записать следующим образом:

int perimeter = length*2+width*2;

что слишком громоздко и провоцирует ошибки.

int perimeter = length+width*2; // сложить width*2 с length

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

perimeter

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

length+width*2

length+(width*2)

a*b+c/d

(a*b)+(c/d)

a*(b+c)/d

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

a*b+c/d

(a*b)+(c/d)

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

a*b+c/d*(e–f/g)/h+7 // слишком сложно

и всегда старайтесь выбирать осмысленные имена.