Программирование — страница 19 из 57

Объекты, типы и значения

“Фортуна благоволит подготовленному уму”.

Луи Пастер (Louis Pasteur)

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

3.1. Ввод

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

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

Например, на рисунке изображен объект типа int с именем age, содержащий целое число 42. Используя строковую переменную, мы можем считать строку с устройства ввода и вывести ее на экран, как показано ниже.

// считать и записать имя
#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() известны нам из главы 2. Поскольку директива #include необходима во всех наших программах (вплоть до главы 12), мы отложим ее изучение, чтобы не запутывать ситуацию. Аналогично иногда мы будем демонстрировать код, который работает, только если поместить его в тело функции main() или какой-нибудь другой.

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

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

Первая строка функции main() просто выводит на экран сообщение, предлагающее пользователю ввести свое имя. Такое сообщение называется приглашением (prompt), поскольку оно предлагает пользователю предпринять какое-то действие. Следующие строки определяют переменную типа string с именем first_name, считывают данные с клавиатуры в эту переменную и выводят на экран слово Hello. Рассмотрим эти строки по очереди.

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

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

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

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

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

Имя cin относится к стандартному потоку ввода (читается как “си-ин” и является аббревиатурой от haracter put), определенному в стандартной библиотеке. Второй операнд оператора >> (“ввести”) определяет участок памяти, в который производится ввод. Итак, если мы введем некое имя, например 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 используется по историческим причинам: оно является сокращением от выражения “число с плавающей точкой и двойной точностью” (“double precision floating point.”) Числом с плавающей точкой в компьютерных науках называют действительное число.

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

39          // int: целое число
3.5         // double: число с плавающей точкой
'.'         // char: отдельный символ, заключенный в одинарные кавычки
"Annemarie" // string: набор символов, выделенный двойными кавычками
true        // bool: либо истина, либо ложь

Иначе говоря, последовательность цифр (например, 1234, 2 или 976) означает целое число, отдельный символ в одинарных кавычках (например, '1', '@' или 'x') означает символ, последовательность цифр с десятичной точкой (например, 1.234, 0.12 или .98) означает число с плавающей точкой, а последовательность символов, заключенных в двойные кавычки (например, "1234", "Howdy!" или "Annemarie"), обозначает строку. Подробное описание литералов приведено в разделе А.2.

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 — в переменную age и выведет на экран следующий результат.

Hello, Carlos (age 22)

Почему вся строка Carlos 22 не была введена в переменную first_name? Потому что по умолчанию считывание строк прекращается, как только будет обнаружен так называемый разделитель (whitespace), т.е. пробел, символ перехода на новую строку или символ табуляции. В других ситуациях разделители по умолчанию игнорируются оператором >>. Например, перед считываемым числом можно поместить сколько угодно пробелов; оператор >> пропустит их и считает число.

Если вы наберете на клавиатуре строку 22 Carlos, то увидите нечто неожиданное. Число 22 будет считано в переменную first_name, так как, в конце концов, 22 — это тоже последовательность символов. С другой стороны, строка Carlos не является целым числом, поэтому она не будет считана. В результате на экран будет выведено число 22, за которым будет следовать строковый литерал " (age" и какое-то случайное число, например –96739 или 0. Почему? Потому что вы не указали начальное значение переменной age и впоследствии в нее ничего не записали. В итоге получили какое-то “мусорное значение”, хранившееся в участке памяти в момент запуска программы. В разделе 10.6 мы покажем способ исправления ошибок, связанных с форматом ввода. А пока просто инициализируем переменную 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) из стандартной библиотеки. Система обозначений близка к математической. Более подробно функции рассматриваются в разделах 4.5 и 8.5.

ПОПРОБУЙТЕ

Запустите эту небольшую программу. Затем измените ее так, чтобы считать значение типа int, а не double. Обратите внимание на то, что функция sqrt() для целых чисел не определена, поэтому присвойте число переменной типа double и лишь затем примените к ней функцию sqrt(). Кроме того, выполните несколько других операций. Обратите внимание на то, что операция для целых чисел представляет собой целочисленное деление, а операция — вычисление остатка, так что 5/2 равно 2 (а не 2.5 или 3), а 5%2 равно 1. Определения целочисленных операций *, / и % гарантируют, что для двух положительных переменных a и b типа int выполняется равенство a/b*b+a%b==a.

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

// ввод имени и отчества
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, смысл которой будет подробно изложен в разделе 4.4.1.1.

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.5.1. Пример: выявление повторяющихся слов

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

int main()
{
  string previous = " ";     // переменная previous;
                             // инициализована "не словом"
  string current;            // текущее слово
  while (cin>>current) {     // считываем поток слов
    if (previous == current) // проверяем, совпадает ли
                             // слово с предыдущим
    cout << " повторяющееся слово: " << current << '\n';
    previous = current;
  }
}

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

string current; // текущее слово

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

while (cin>>current)

 Эта конструкция, называемая инструкцией while, интересна сама по себе, поэтому мы еще вернемся к ней в разделе 4.4.2.1. Ключевое слово while означает, что инструкция, стоящая следом за выражением cin>>current, будет повторяться до тех пор, пока выполняется операция cin>>current, а операция cin>>current будет выполняться до тех пор, пока в стандартном потоке ввода есть символы.

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

, а затем — клавиши . В системе Unix или Linux для этого используется комбинация клавиш .

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

if (previous == current)  // проверяем, совпадает ли слово
                          // с предыдущим
  cout << " повторяющееся слово: " << current << '\n';

Теперь мы должны повторить описанную операцию. Для этого копируем значение переменной current в переменную previous.

previous = current;

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

string previous = " "; // переменная previous; инициализована
                       // "не словом"

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

if (previous == current)

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

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

ПОПРОБУЙТЕ

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

ПОПРОБУЙТЕ

Запустите программу для выявления повторяющихся слов. Проверьте предложение “She she laughed He He because what he did did not look very very good good”. Сколько раз повторяются слова в этом предложении? Почему? Что значит слово в этой программе? А что значит повторяющееся слово? (Например, “She she” — это повтор или нет?).

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 (см. раздел А.5). Благодаря этому правилу можно составить операторы +=, –=, *=, /= и %=. Эта компактная запись позволяет просто и ясно выражать свои идеи. Например, во многих приложениях операторы *= и /= означают масштабирование.

3.6.1. Пример: поиск повторяющихся слов

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

int main()
{
  int number_of_words = 0;
  string previous = " ";  // не слово
  string current;
  while (cin >> current) {
    ++number_of_words;    // увеличиваем счетчик слов
    if (previous == current)
      cout << " количество слов " << number_of_words
<< " repeated: " << current << '\n';
    previous = current;
  }
}

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

++number_of_words;

Таким образом, первое слово имеет номер 1, второе — 2 и т.д. Эту операцию можно записать иначе:

number_of_words += 1;

или даже так:

number_of_words = number_of_words+1;

но выражение ++number_of_words короче и выражает идею инкрементации намного проще. 

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

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 — локальная переменная или параметр (см. разделы 4.5 и 8.4), а i — счетчик цикла (см. раздел 4.4.2.3).

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

partial_sum
element_count
stable_partition

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

the_number_of_elements
remaining_free_slots_in_symbol_table

Мы предпочитаем использовать в качестве разделителей слов в идентификаторе символы подчеркивания, например element_count, а не elementCount или Element-Count. Мы никогда не используем имена, состоящие лишь из прописных букв, такие как ALL_CAPITAL_LETTERS, поскольку по умолчанию они зарезервированы для макросов (см. разделы 27.8 и A.17.2), которых мы избегаем. Мы используем прописные буквы в качестве первых букв в именах типов, например Square и Graph. В языке С++ и его стандартной библиотеке прописные буквы не используются, поэтому типы называются int и string, а не Int и String. Таким образом, принятое правило позволяет минимизировать вероятность конфликтов имен между пользовательскими и стандартными типами

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

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

Name names nameS
foo f00 fl
f1 fI fi

Символы 0, o, O, 1, l, I особенно часто порождают ошибки. 

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

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

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

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

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

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

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

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

Неформально объект можно представить в виде ящика, в который можно положить значения определенного типа. В ящике для объектов типа int можно хранить только целые числа, например 7, 42 и –399. В ящике для объектов типа string можно хранить символьные строки, например "Interoperability", "tokens: @#$%^&*" и "Old MacDonald had a farm". Графически это можно представить так:

Представление объекта типа string немного сложнее, чем объекта типа int, так как тип string хранит количество символов в строке. Обратите внимание на то, что объект типа double хранит число, а объект типа string — символы. Например, переменная x содержит число 1.2, а переменная s2 — три символа: '1', '.' и '2'. Кавычки вокруг символа и строковых литералов в переменных не хранятся.

Все переменные типа int имеют одинаковый размер; иначе говоря, для каждой переменной типа int компилятор выделяет одинаковое количество памяти. В типичном настольном компьютере этот объем равен 4 байтам (32 бита). Аналогично, объекты типов bool, char и double имеют фиксированный размер. В настольном компьютере переменные типа bool и char, как правило, занимают один байт (8 бит), а переменная типа double — 8 байт. Обратите внимание на то, что разные типы объектов занимают разное количество памяти в компьютере. В частности, переменная типа char занимает меньше памяти, чем переменная типа int, а переменная типа string отличается от переменных типов double, int и char тем, что разные строки занимают разное количество памяти.

Смысл битов, размещенных в памяти, полностью зависит от типа, используемого для доступа к этим битам. Это следует понимать следующим образом: память компьютера ничего не знает о типах; это просто память, и больше ничего. Биты, расположенные в этой памяти, приобретают смысл, только когда мы решаем, как интерпретировать данный участок памяти. Такая ситуация вполне типична при повседневном использовании чисел. Что значит 12.5? Мы не знаем. Это может быть 12.5 долл., 12.5 см или 12.5 галлонов. Только после того, как мы припишем числу 12.5 единицу измерения, оно приобретет конкретный смысл. Например, один и тот же набор битов в памяти может представлять число 120, если его интерпретировать как переменную типа int, и символ 'x', если трактовать его как объект типа char. Если взглянуть на него как на объект типа string, то он вообще потеряет смысл и попытка его использовать приведет к ошибке, возникшей в ходе выполнения программы. Эту ситуацию можно проиллюстрировать следующим образом (здесь 1 и 0 означают значения битов в памяти).

Этот набор битов, записанных в участке памяти (слове), можно прочитать как переменную типа int (120) или char ('x'), если учитывать только младшие биты. Бит — это единица памяти компьютера, которая может хранить либо 0, либо 1.

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

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

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

int main()
{
  double x;         // мы забыли проинициализировать переменную х:
                    // ее значение не определено
  double y = x;     // значение переменной y не определено
  double z = 2.0+x; // смысл операции + и значение переменной z
   // не определены
}

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

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

3.9.1. Безопасные преобразования

В разделе 3.4 мы видели, что нельзя непосредственно складывать объекты типа char или сравнивать объекты типов double и int. Однако в языке С++ это можно сделать косвенным образом. При необходимости объект типа char можно преобразовать в объект типа int, а объект типа int — в объект типа double. Рассмотрим пример.

char c = 'x';
int i1 = c;
int i2 = 'x';

Здесь значения переменных i1 и i2 равны 120, т.е. 8-битовому ASCII коду символа 'x'. Это простой и безопасный способ получения числового представления символа. Мы называем это преобразование типа char в тип int безопасным, поскольку при этом не происходит потери информации; иначе говоря, мы можем скопировать результат, хранящийся в переменной типа int, обратно в переменную типа char и получить исходное значение.

char c2 = i1;
cout << c << ' ' << i1 << ' ' << c2 << '\n';

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

x 120 x

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

bool в charbool в intbool в doublechar в intchar в doubleint в double

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

double d1 = 2.3;
double d2 = d1+2;  // перед сложением число преобразуется в число 2.0
if (d1 < 0)        // перед сравнением число 0 преобразуется в число 0.0
  cout("d1 — отрицательно");

Для действительно больших чисел типа int при их преобразовании в переменные типа double мы можем (в некоторых компьютерах) потерять точность. Однако эта проблема возникает редко.

3.9.2. Опасные преобразования

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

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

int main()
{
  int a = 20000;
  char c = a;  // попытка втиснуть большое значение типа int
               // в маленькую переменную типа char
  int b = c;
  if (a != b)  // != означает "не равно"
    cout << "Ой!: " << a << "!=" << b << '\n';
  else
    cout << "Ого! Мы получили большие значения типа char\n";
}

Такие преобразования называют “сужающими”, поскольку они заносят значение в объект, размер которого слишком мал (“узок”) для их хранения. К сожалению, лишь некоторые компиляторы предупреждают об опасной инициализации переменной типа char значением переменной типа int. Проблема заключается в том, что тип int, как правило, намного больше типа char, так что он может (в нашем случае так и происходит) хранить значение типа int, которое невозможно представить как значение типа char. Попробуйте выяснить, чему равна переменная b на вашей машине (обычно должно получиться 32); поэкспериментируйте.

int main()
{
 double d = 0;
 while (cin>>d) {             // повторяем последующие инструкции,
                              // пока мы вводим целые числа
   int i = d;                 // попытка втиснуть double в int
   char c = i;                // попытка втиснуть int в char
   int i2 = c;                // получаем целое значение переменной типа char
   cout << " d==" << d        // исходное значение типа double
<< " i==" << i             // преобразуется в значение типа int
<< " i2==" << i2           // целое значение переменной типа char
<< " char(" << c << ")\n"; // значение типа char
 }
}

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

ПОПРОБУЙТЕ

Выполните эту программу, вводя разные значения. Попробуйте ввести небольшие значения (например, 2 и 3); большие значения (больше чем 127, больше чем 1000); отрицательные значения; введите число 56; 89; 128; неотрицательные целые числа (например, 56.9 и 56.2). Кроме демонстрации преобразования типа double в тип int и типа int в тип char на вашем компьютере, эта программа показывает, какое значение типа char выводится для заданного целого числа.

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

double в intdouble в chardouble в boolint в charint в boolchar в bool

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

double x = 2.7;
// какой-то код
int y = x; // значение переменной y становится равным 2

С момента определения переменной y вы могли забыть, что переменная x имеет тип double, или упустить из виду, что преобразование double в int приводит к усечению (округлению вниз). Результат вполне предсказуем: семь десятых потеряны. Преобразование int в char не порождает проблем с усечением — ни тип int, ни тип char невозможно представить в виде дробной части целого числа. Однако переменная типа char может хранить только очень небольшие целые числа. В персональных компьютерах переменная типа char занимает 1 байт, в то время как переменная типа int — 4 байта.

 Итак, мы не можем записать большое число, например 1000, в переменную типа char без потери информации: значение “сужается”. Рассмотрим пример.

int a = 1000;
char b = a; // переменная b становится равной –24

Не все значения типа int эквивалентны значению типа char. Точный диапазон значения типа char зависит от конкретной реализации. На персональных компьютерах значения типа char колеблются в диапазоне [–128:127], но мобильность программ можно обеспечить только в диапазоне [0:127], поскольку не каждый компьютер является персональным, и на некоторых из них значения типа char лежат в диапазоне [0:255].

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

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

Задание

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

1. Напишите программу, формирующую простую форму для письма на основе входной информации. Для начала наберите программу из раздела 3.1, предложив пользователю ввести свое имя и предусмотрев вывод строки “Hello, first_name”, где first_name — это имя, введенное пользователем. Затем модифицируйте программу следующим образом: измените приглашение на строку “Введите имя адресата” и измените вывод на строку “Dear first_name,”. Не забудьте о запятой.

2. Введите одну или две вступительные фразы, например “Как дела? У меня все хорошо. Я скучаю по тебе”. Убедитесь, что первая строка отделена от других. Добавьте еще несколько строк по своему усмотрению — это же ваше письмо.

3. Предложите пользователю ввести имя другого приятеля и сохраните его в переменной friend_name. Добавьте в ваше письмо следующую строку: “Видел ли ты friend_name недавно?”.

4. Объявите переменную типа char с именем friend_sex и инициализируйте его нулем. Предложите пользователю ввести значение m, если ваш друг — мужчина, и f — если женщина. Присвойте переменной friend_sex введенное значение. Затем с помощью двух инструкций if запишите следующее. Если друг — мужчина, то напишите строку: “Если ты увидишь friend_name, пожалуйста, попроси его позвонить мне”. Если друг — женщина, то напишите строку: “Если ты увидишь friend_name, пожалуйста, попроси ее позвонить мне”.

5. Предложите пользователю ввести возраст адресата и присвойте его переменной age, имеющей тип int. Ваша программа должна вывести на экран строку: “Я слышал, ты только что отметил день рождения и тебе исполнилось age лет”. Если значение переменной age меньше или равно 0 или больше или равно 110, выведите на экран строку simple_error("ты шутишь!"), используя функцию simple_error() из заголовочного файла std_lib_facilities.h.

6. Добавьте в ваше письмо следующие строки Если вашему другу меньше 12 лет, напишите: “На следующий год тебе исполнится age+1 лет”. Если вашему другу 18 лет, напишите: “На следующий год ты сможешь голосовать”. Если вашему другу больше 60 лет, напишите: “Я надеюсь, что ты не скучаешь на пенсии”. Убедитесь, что ваша программа правильно обрабатывает каждое из этих значений.

7. Добавьте строку “Искренне твой,” затем введите две пустые строки для подписи и укажите свое имя.

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

1. Что подразумевается под приглашением?

2. Какой оператор используется для ввода переменной?

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

4. Как называется символ \n и для чего он предназначен?

5. Что является признаком конца строки?

6. Как прекращается ввод значения в целочисленную переменную?

7. Как записать 

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

в одной строке?

8. Что такое объект?

9. Что такое литерал?

10. Какие существуют виды литералов?

11. Что такое переменная?

12. Назовите типичные размеры переменных типов char, int и double?

13. В каких единицах измеряется объем памяти, занимаемой небольшими переменными, например объектами типов int и string?

14. В чем заключается разница между операторами = и ==?

15. Что такое определение?

16. Что такое инициализация и чем она отличается от присваивания?

17. Что такое конкатенация строк и как она выполняется в языке С++?

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

This_little_pig This_1_is fine 2_For_1_special
latest thing the_$12_method _this_is_ok
MiniMineMine number correct?

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

20. Сформулируйте разумные правила для выбора имен.

21. Что такое типовая безопасность и почему она так важна?

22. Почему преобразование типа double в тип int может привести к неверным результатам?

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

Термины

Упражнения

1. Выполните задание из раздела ПОПРОБУЙТЕ, если вы не сделали его раньше.

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

3. Напишите программу, которая ничего не делает, а просто объявляет переменные с допустимыми и недопустимыми именами (например, int double = 0;), и посмотрите на реакцию компилятора.

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

5. Измените программу так, чтобы пользователь вводил числа с плавающей точкой и сохранял их в переменных типа double. Сравните результаты работы этих двух программ на нескольких вариантах. Совпадают ли эти результаты? Должны ли они совпадать? Чем они отличаются?

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

7. Выполните упр. 6 для трех строковых значений. Так, если пользователь вводит значения "Steinbeck", "Hemingway", "Fitzgerald", то программа должна вывести на экран строку "Fitzgerald, Hemingway, Steinbeck".

8. Напишите программу, проверяющую четность или нечетность целого числа. Как всегда, убедитесь, что результат ясен и полон. Иначе говоря, не следует ограничиваться простой констатацией вроде “да” или “нет”. Вывод должен быть информативным, например “Число 4 является четным”. Подсказка: см. оператор вычисления остатка в разделе 3.4.

9. Напишите программу, преобразующую слова “нуль”, “два” и т.д. в цифры 0, 2 и т.д. Когда пользователь вводит число в виде слова, программа должна вывести на экран соответствующую цифру. Выполните эту программу для цифр 0, 1, 2, 3 и 4. Если пользователь введет что-нибудь другое, например фразу “глупый компьютер!”, программа должна ответить “Я не знаю такого числа!”

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

+ 100 3.14
* 4 5

Считайте символ операции в объект типа string с именем operation и, используя инструкцию if, выясните, какую операцию хочет выполнить пользователь, например if (operation=="+"). Считайте операнды в переменные типа double. Выполните операции с именами +, –, *, /, plus, minus, mul и div, имеющие очевидный смысл.

11. Напишите программу, предлагающую пользователю ввести определенное количество 1-, 5-, 10-, 25-, 50-центовых и долларовых монет. Пользователь должен по отдельности ввести количество монет каждого достоинства, например “Сколько у вас одноцентовых монет?” Результат должен выглядеть следующим образом.

 У вас 23 одноцентовые монеты.

 У вас 17 пятицентовых монет.

 У вас 14 десятицентовых монет.

 У вас 7 25-центовых монет.

 У вас 3 50-центовые монеты.

 Общая стоимость ваших монет равна 573 центам.

Усовершенствуйте программу: если у пользователя только одна монета, выведите ответ в грамматически правильной форме. Например, “14 десятицентовых монет” и “1 одноцентовая монета” (а не “1 одноцентовых монет”). Кроме того, выведите результат в долларах и центах, т.е. 5,73 доллара, а не 573 цента.

Послесловие

Не следует недооценивать важность типовой безопасности. Тип — наиболее важное понятие для создания правильных программ, и некоторые из наиболее эффективных методов разработки программ основаны на разработке и использовании типов (см. главы 6 и 9, части II–IV). 

Глава 4