Основные типы данных C++

.

Как вы узнали, все переменные в C++ должны быть объявлены до их использования. Это необходимо для компилятора, которому нужно иметь информацию о типе данных, содержащихся в переменных. Только в этом случае компилятор сможет надлежащим образом скомпилировать инструкции, в которых используются переменные. В C++ определено семь основных типов данных: символьный, символьный двубайтовый, целочисленный, с плавающей точкой, с плавающей точкой двойной точности, логический (или булев) и «не имеющий значения». Для объявления переменных этих типов используются ключевые слова char, wchar_t, int, float, double, bool и void соответственно.

Помните, что размеры и диапазоны, используемые вашим компилятором, могут отличаться от приведенных здесь. Самое большое различие существует между 16- и 32-разрядными средами: для представления целочисленного значения в 16-разрядной среде используется, как правило, 16 бит, а в 32-разрядной — 32.
Переменные типа char используются для хранения 8-разрядных ASCII-символов (например букв А, Б или В) либо любых других 8-разрядных значений. Чтобы задать символ, необходимо заключить его в одинарные кавычки. Тип wchar_t предназначен для хранения символов, входящих в состав больших символьных наборов. Вероятно, вам известно, что в некоторых естественных языках (например китайском) определено очень большое количество символов, для которых 8-разрядное представление (обеспечиваемое типом char) весьма недостаточно. Для решения проблем такого рода в язык C++ и был добавлен тип wchar_t, который вам пригодится, если вы планируете выходить со своими программами на международный рынок.
Переменные типа int позволяют хранить целочисленные значения (не содержащие дробных компонентов). Переменные этого типа часто используются для управления циклами и в условных инструкциях. К переменным типа float и double обращаются либо для обработки чисел с дробной частью, либо при необходимости выполнения операций над очень большими или очень малыми числами. Типы float и double различаются значением наибольшего (и наименьшего) числа, которые можно хранить с помощью переменных этих типов. Как показано в табл. 3.1, тип double в C++ позволяет хранить число, приблизительно в десять раз превышающее значение типа float.
Тип bool предназначен для хранения булевых (т.е. ИСТИНА/ЛОЖЬ) значений. В C++ определены две булевы константы: true и false, являющиеся единственными значениями, которые могут иметь переменные типа bool.
Как вы уже видели, тип void используется для объявления функции, которая не возвращает значения. Другие возможности использования типа void рассматриваются ниже в этой книге.
Объявление переменных
Общий формат инструкции объявления переменных выглядит так:

тип список_переменных;
Здесь элемент тип означает допустимый в C++ тип данных, а элемент список_переменных может состоять из одного или нескольких имен (идентификаторов), разделенных запятыми. Вот несколько примеров объявлений переменных.

int i, j, k;

char ch, chr;

float f, balance;

double d;
В C++ имя переменной никак не связано с ее типом.
Согласно стандарту C++ первые 1024 символа любого имени (в том числе и имени переменной) являются значимыми. Это означает, что если два имени различаются хотя бы одним символом из первых 1024, компилятор будет рассматривать их как различные имена.
Переменные могут быть объявлены внутри функций, в определении параметров функций и вне всех функций. В зависимости от места объявления они называются локальными переменными, формальными параметрами и глобальными переменными соответственно. О важности этих трех типов переменных мы поговорим ниже в этой книге, а пока кратко рассмотрим каждый тип в отдельности.
Локальные переменные
Переменные, которые объявляются внутри функции, называются локальными. Их могут использовать только инструкции, относящиеся к телу функции. Локальные переменные неизвестны внешним функциям. Рассмотрим пример.

#include <iostream>

using namespace std;

void func ();

int main ()

{

int x; // Локальная переменная для функции main ().

х = 10;

func ();

cout << «\n»;

cout << x; // Выводится число 10.

return 0;

}

void func ()

{

int x; // Локальная переменная для функции func ().

x = -199;

cout << x; // Выводится число -199.

}
Локальная переменная известна только функции, в которой она определена.
В этой программе целочисленная переменная с именем х объявлена дважды: сначала в функции main (), а затем в функции func (). Но переменная х из функции main () не имеет никакого отношения к переменной х из функции func (). Другими словами, изменения, которым подвергается переменная х из функции func (), никак не отражаются на переменной х из функции main (). Поэтому приведенная выше программа выведет на экран числа -199 и 10.
В C++ локальные переменные создаются при вызове функции и разрушаются при выходе из нее. То же самое можно сказать и о памяти, выделяемой для локальных переменных: при вызове функции в нее записываются соответствующие значения, а при выходе из функции память освобождается. Это означает, что локальные переменные не поддерживают своих значений между вызовами функций. (Другими словами, значение локальной переменной теряется при каждом возврате из функции.)
В некоторых литературных источниках, посвященных C++, локальная переменная называется динамической или автоматической переменной. Но в этой книге мы будем придерживаться более распространенного термина локальная переменная.
Формальные параметры
Формальный параметр — это локальная переменная, которая получает значение аргумента, переданного функции.
Как отмечалось в главе 2, если функция имеет аргументы, то они должны быть объявлены. Их объявление осуществляется с помощью формальных параметров. Как показано в следующем фрагменте, формальные параметры объявляются после имени функции, внутри круглых скобок.

int funс1 (int first, int last, char ch)

{

.

.

.

}
Здесь функция funс1 () имеет три параметра с именами first, last и ch. С помощью такого объявления мы сообщаем компилятору тип каждой из переменных, которые будут принимать значения, передаваемые функции. Несмотря на то что формальные параметры выполняют специальную задачу получения значений аргументов, передаваемых функции, их можно также использовать в теле функции как обычные локальные переменные. Например, мы можем присвоить им любые значения или использовать в ка-ких-нибудь (допустимых для C++) выражениях. Но, подобно любым другим локальным переменным, их значения теряются по завершении функции.
Глобальные переменные
Глобальные переменные известны всей программе.
Чтобы придать переменной «всепрограммную» известность, ее необходимо сделать глобальной. В отличие от локальных, глобальные переменные хранят свои значения на протяжении всего времени жизни (времени существования) программы. Чтобы создать глобальную переменную, ее необходимо объявить вне всех функций. Доступ к глобальной переменной можно получить из любой функции.
В следующей программе переменная count объявляется вне всех функций. Ее объявление предшествует функции main (). Но ее с таким же успехом можно разместить в другом месте, главное, чтобы она не принадлежала какой-нибудь функции. Помните: поскольку переменную необходимо объявить до ее использования, глобальные переменные лучше всего объявлять в начале программы.

#include <iostream>

using namespace std;

void funс1 ();

void func2 ();

int count; // Это глобальная переменная.

int main ()

{

int i; // Это локальная переменная.

for (i=0; i<10; i++){

count = i * 2;

funс1 ();

}

return 0;

}

void func1 ()

{

cout << "count: " << count; // Обращение к глобальной переменной.

cout << '\n'; // Вывод символа новой строки.

func2 ();

}

void func2 ()

{

int count; // Это локальная переменная.

for (count=0; count<3; count++) cout <<'.';

}
Несмотря на то что переменная count не объявляется ни в функции main (), ни в функции func1 (), обе они могут ее использовать. Но в функции func2 () объявляется локальная переменная count. Здесь при обращении к переменной count выполняется доступ к локальной, а не к глобальной переменной. Важно помнить, что, если глобальная и локальная переменные имеют одинаковые имена, все ссылки на «спорное» имя переменной внутри функции, в которой определена локальная переменная, относятся к локальной, а не к глобальной переменной.
Модификаторы типов
В C++ перед такими типами данных, как char, int и double, разрешается использовать модификаторы. Модификатор служит для изменения значения базового типа, чтобы он более точно соответствовал конкретной ситуации. Перечислим возможные модификаторы типов.

signed

unsigned

long

short
Модификаторы signed, unsigned, long и short можно применять к целочисленным базовым типам. Кроме того, модификаторы signed и unsigned можно использовать с типом char, а модификатор long— с типом double. Все допустимые комбинации базовых типов и модификаторов для 16- и 32-разрядных сред приведены в табл. 3.2 и 3.3. В этих таблицах также указаны типичные размеры значений в битах и диапазоны представления для каждого типа. Безусловно, реальные диапазоны, поддерживаемые вашим компилятором, следует уточнить в соответствующей документации.
Изучая эти таблицы, обратите внимание на количество битов, выделяемых для хранения коротких, длинных и обычных целочисленных значений. Заметьте: в большинстве 16-разрядных сред размер (в битах) обычного целочисленного значения совпадает с размером короткого целого. Также отметьте, что в большинстве 32-разрядных сред размер (в битах) обычного целочисленного значения совпадает с размером длинного целого. «Собака зарыта» в С++-определении базовых типов. Согласно стандарту C++ размер длинного целого должен быть не меньше размера обычного целочисленного значения, а размер обычного целочисленного значения должен быть не меньше размера короткого целого. Размер обычного целочисленного значения должен зависеть от среды выполнения. Это значит, что в 16-разрядных средах для хранения значений типа int используется 16 бит, а в 32-разрядных — 32. При этом наименьший допустимый размер для целочисленных значений в любой среде должен составлять 16 бит. Поскольку стандарт C++ определяет только относительные требования к размеру целочисленных типов, нет гарантии, что один тип будет больше (по количеству битов), чем другой. Тем не менее размеры, указанные в обеих таблицах, справедливы для многих компиляторов.
Несмотря на разрешение, использование модификатора signed для целочисленных типов избыточно, поскольку объявление по умолчанию предполагает значение со знаком. Строго говоря, только конкретная реализация определяет, каким будет char-объявление: со знаком или без него. Но для большинства компиляторов объявление типа char подразумевает значение со знаком. Следовательно, в таких средах использование модификатора signed для char-объявления также избыточно. В этой книге предполагается, что char-значения имеют знак.
Различие между целочисленными значениями со знаком и без него заключается в интерпретации старшего разряда. Если задано целочисленное значение со знаком, С++-компилятор сгенерирует код с учетом того, что старший разряд значения используется в качестве флага знака. Если флаг знака равен 0, число считается положительным, а если он равен 1, — отрицательным. Отрицательные числа почти всегда представляются в дополнительном коде. Для получения дополнительного кода все разряды числа берутся в обратном коде, а затем полученный результат увеличивается на единицу.
Целочисленные значения со знаком используются во многих алгоритмах, но максимальное число, которое можно представить со знаком, составляет только половину от максимального числа, которое можно представить без знака. Рассмотрим, например, максимально возможное 16-разрядное целое число (32 767):
0 1111111 11111111
Если бы старший разряд этого значения со знаком был установлен равным 1, то оно бы интерпретировалось как -1 (в дополнительном коде). Но если объявить его как unsigned int-значение, то после установки его старшего разряда в 1 мы получили бы число 65 535.
Чтобы понять различие в С++-интерпретации целочисленных значений со знаком и без него, выполним следующую короткую программу.

#include <iostream>

using namespace std;

/* Эта программа демонстрирует различие между signed- и unsigned-значениями целочисленного типа.

*/

int main ()

{

short int i; // короткое int-значение со знаком

short unsigned int j; // короткое int-значение без знака

j = 60000;

i = j;

cout << i << " « << j;

return 0;

}
При выполнении программа выведет два числа:

— 5536 60000
Дело в том, что битовая комбинация, которая представляет число 60000 как короткое целочисленное значение без знака, интерпретируется в качестве короткого int-значения со знаком как число -5536.
В C++ предусмотрен сокращенный способ объявления unsigned- , short- и long-значений целочисленного типа. Это значит, что при объявлении int-значений достаточно использовать слова unsigned, short и long, не указывая тип int, т.е. тип int подразумевается. Например, следующие две инструкции объявляют целочисленные переменные без знака.

unsigned х;

unsigned int у;
Переменные типа char можно использовать не только для хранения ASCII-символов, но и для хранения числовых значений. Переменные типа char могут содержать „небольшие“ целые числа в диапазоне -128--127 и поэтому их можно использовать вместо int-переменных, если вас устраивает такой диапазон представления чисел. Например, в следующей программе char-переменная используется для управления циклом, который выводит на экран алфавит английского языка.

// Эта программа выводит алфавит в обратном порядке.

#include <iostream>

using namespace std;

int main ()

{

char letter;

for (letter='Z'; letter >= 'A'; letter--) cout << letter;

return 0;

}
Если цикл for вам покажется несколько странным, то учтите, что символ 'А' представляется в компьютере как число, а значения от 'Z' до 'А' являются последовательными и расположены в убывающем порядке.
Литералы
Литералы, называемые также константами, — это фиксированные значения, которые не могут быть изменены программой. Мы уже использовали литералы во всех предыдущих примерах программ. А теперь настало время изучить их более подробно.
Константы могут иметь любой базовый тип данных. Способ представления каждой константы зависит от ее типа. Символьные константы заключаются в одинарные кавычки. Например, 'а' и '%' являются символьными литералами. Если необходимо присвоить символ переменной типа char, используйте инструкцию, подобную следующей:

ch = 'Z';
Чтобы использовать двубайтовый символьный литерал (т.е. константу типа wchar_t), предварите нужный символ буквой L. Например, так.

wchar_t wc;

wc = L'A';
Здесь переменной wc присваивается двубайтовая символьная константа, эквивалентная букве А.
Целочисленные константы задаются как числа без дробной части. Например, 10 и -100 — целочисленные литералы. Вещественные литералы должны содержать десятичную точку, за которой следует дробная часть числа, например 11.123. Для вещественных констант можно также использовать экспоненциальное представление чисел.
Существует два основных вещественных типа: float и double. Кроме того, существует несколько модификаций базовых типов, которые образуются с помощью модификаторов типов. Интересно, а как же компилятор определяет тип литерала? Например, число 123.23 имеет тип float или double? Ответ на этот вопрос состоит из двух частей. Во-первых, С++-компилятор автоматически делает определенные предположения насчет литералов. Во-вторых, при желании программист может явно указать тип литерала.
По умолчанию компилятор связывает целочисленный литерал с совместимым и одновременно наименьшим по занимаемой памяти тип данных, начиная с типа int. Следовательно, для 16-разрядных сред число 10 будет связано с типом int, а 103 000— с типом long int.
Единственным исключением из правила „наименьшего типа“ являются вещественные (с плавающей точкой) константы, которым по умолчанию присваивается тип double. Во многих случаях такие стандарты работы компилятора вполне приемлемы. Однако у программиста есть возможность точно определить нужный тип.
Чтобы задать точный тип числовой константы, используйте соответствующий суффикс. Для вещественных типов действуют следующие суффиксы: если вещественное число завершить буквой F, оно будет обрабатываться с использованием типа float, а если буквой L, подразумевается тип long double. Для целочисленных типов суффикс U означает использование модификатора типа unsigned, а суффикс L— long. (Для задания модификатора unsigned long необходимо указать оба суффикса U и L.) Ниже приведены некоторые примеры.
Шестнадцатеричные и восьмеричные литералы
Иногда удобно вместо десятичной системы счисления использовать восьмеричную или шестнадцатеричную. В восьмеричной системе основанием служит число 8, а для выражения всех чисел используются цифры от 0 до 7. В восьмеричной системе число 10 имеет то же значение, что число 8 в десятичной. Система счисления по основанию 16 называется шестнадцатеричной и использует цифры от 0 до 9 плюс буквы от А до F, означающие шестнадцатеричные „цифры“ 10, 11, 12, 13, 14 и 15. Например, шестнадцатеричное число 10 равно числу 16 в десятичной системе. Поскольку эти две системы счисления (шестнадцатеричная и восьмеричная) используются в программах довольно часто, в языке C++ разрешено при желании задавать целочисленные литералы не в десятичной, а в шестнадцатеричной или восьмеричной системе. Шестнадцатеричный литерал должен начинаться с префикса 0x (нуль и буква х) или 0Х, а восьмеричный — с нуля. Приведем два примера.

int hex = OxFF; // 255 в десятичной системе

int oct = 011; // 9 в десятичной системе
Строковые литералы
Язык C++ поддерживает еще один встроенный тип литерала, именуемый строковым. Строка— это набор символов, заключенных в двойные кавычки, например „это тест“. Вы уже видели примеры строк в некоторых cout-инструкциях, с помощью которых мы выводили текст на экран. При этом обратите внимание вот на что. Хотя C++ позволяет определять строковые литералы, он не имеет встроенного строкового типа данных. Строки в C++, как будет показано ниже в этой книге, поддерживаются в виде символьных массивов. (Кроме того, стандарт C++ поддерживает строковый тип с помощью библиотечного класса string, который также описан ниже в этой книге.)
Осторожно! Не следует путать строки с символами. Символьный литерал заключается в одинарные кавычки, например 'а'. Однако „а“ — это уже строка, содержащая только одну букву.
Управляющие символьные последовательности
С выводом большинства печатаемых символов прекрасно справляются символьные константы, заключенные в одинарные кавычки, но есть такие „экземпляры“ (например, символ возврата каретки), которые невозможно ввести в исходный текст программы с клавиатуры. Некоторые символы (например, одинарные и двойные кавычки) в C++ имеют специальное назначение, поэтому иногда их нельзя ввести напрямую. По этой причине в языке C++ разрешено использовать ряд специальных символьных последовательностей (включающих символ „обратная косая черта“), которые также называются управляющими последовательностями. Их список приведен в табл. 3.4.
Использование управляющих последовательностей демонстрируется на примере следующей программы. При ее выполнении будут выведены символы перехода на новую строку, обратной косой черты и возврата на одну позицию.

#include <iostream>

using namespace std;

int main ()

{

cout<<»\n\\\b";

return 0;

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

тип имя_переменной = значение;
Вот несколько примеров.

char ch = 'а';

int first = 0;

float balance = 123.23F;
Несмотря на то что переменные часто инициализируются константами, C++ позволяет инициализировать переменные динамически, т.е. с помощью любого выражения, действительного на момент инициализации. Как будет показано ниже, инициализация играет важную роль при работе с объектами.
Глобальные переменные инициализируются только в начале программы. Локальные переменные инициализируются при каждом входе в функцию, в которой они объявлены. Все глобальные переменные инициализируются нулевыми значениями, если не указаны никакие иные инициализаторы. Неинициализированные локальные переменные будут иметь неизвестные значения до первой инструкции присваивания, в которой они используются.
Рассмотрим простой пример инициализации переменных. В следующей программе используется функция total (), которая предназначена для вычисления суммы всех последовательных чисел, начиная с единицы и заканчивая числом, переданным ей в качестве аргумента. Например, сумма ряда чисел, ограниченного числом 3, равна 1 + 2 + 3 = 6. В процессе вычисления итоговой суммы функция total () отображает промежуточные результаты. Обратите внимание на использование переменной sum в функции total ().

// Пример использования инициализации переменных.

#include <iostream>

using namespace std;

void total (int x);

int main ()

{

cout << «Вычисление суммы чисел от 1 до 5.\n»;

total (5);

cout << «\n Вычисление суммы чисел от 1 до 6.\n»;

total (6);

return 0;

}

void total (int x)

{

int sum=0; // Инициализируем переменную sum.

int i, count;

for (i=1; i<=x; i++) {

sum = sum + i;

for (count=0; count<10; count++) cout << '.';

cout << "Промежуточная сумма равна " << sum << '\n';

}

}
Результаты выполнения этой программы таковы.

Вычисление суммы чисел от 1 до 5.

..........Промежуточная сумма равна 1

..........Промежуточная сумма равна 3

..........Промежуточная сумма равна 6

..........Промежуточная сумма равна 10

..........Промежуточная сумма равна 15

Вычисление суммы чисел от 1 до 6.

..........Промежуточная сумма равна 1

..........Промежуточная сумма равна 3

..........Промежуточная сумма равна 6

..........Промежуточная сумма равна 10

..........Промежуточная сумма равна 15

..........Промежуточная сумма равна 21
Как видно по результатам, при каждом вызове функции total () переменная sum инициализируется нулем.
Операторы
В C++ определен широкий набор встроенных операторов, которые дают в руки программисту мощные рычаги управления при создании и вычислении разнообразнейших выражений. Оператор (operator) — это символ, который указывает компилятору на выполнение конкретных математических действий или логических манипуляций. В C++ имеется четыре общих класса операторов: арифметические, поразрядные, логические и операторы отношений. Помимо них определены другие операторы специального назначения. В этой главе рассматриваются арифметические, логические и операторы отношений.
Арифметические операторы
В табл. 3.5 перечислены арифметические операторы, разрешенные для применения в C++. Действие операторов +, — , * и / совпадает с действием аналогичных операторов в любом другом языке программирования (да и в алгебре, если уж на то пошло). Их можно применять к данным любого встроенного числового типа. После применения оператора деления (/) к целому числу остаток будет отброшен. Например, результат целочисленного деления 10/3 будет равен 3.
Остаток от деления можно получить с помощью оператора деления по модулю (%). Этот оператор работает практически так же, как в других языках программирования: возвращает остаток от деления нацело. Например, 10%3 равно 1. Это означает, что в C++ оператор «%» нельзя применять к типам с плавающей точкой (float или double). Деление по модулю применимо только к целочисленным типам. Использование этого оператора демонстрируется в следующей программе.

#include <iostream>

using namespace std;

int main ()

{

int x, y;

x = 10;

y = 3;

cout << х/у; // Будет отображено число 3.

cout << «\n»;

cout << х%у; /* Будет отображено число 1, т.е. остаток от деления нацело. */

cout << «\n»;

х = 1;

y = 2;

cout << х/у << " " << х%у; // Будут выведены числа 0 и 1.

return 0;

}
В последней строке результатов выполнения этой программы действительно будут выведены числа 0 и 1, поскольку при целочисленном делении ½ получим 0 с остатком 1, т.е. выражение 1%2 дает значение 1.
Унарный минус, по сути, представляет собой умножение значения своего единственного операнда на -1. Другими словами, любое числовое значение, которому предшествует знак меняет свой знак на противоположный.
Инкремент и декремент
В C++ есть два оператора, которых нет в некоторых других языках программирования. Это операторы инкремента (++) и декремента (--). Они упоминались в главе 2, когда речь шла о цикле for. Оператор инкремента выполняет сложение операнда с числом 1, а оператор декремента вычитает 1 из своего операнда. Это значит, что инструкция

х = х + 1;
аналогична такой инструкции:

++х;
А инструкция

х = х — 1;
аналогична такой инструкции:

— x;
Операторы инкремента и декремента могут стоять как перед своим операндом (префиксная форма), так и после него (постфиксная форма). Например, инструкцию

х = х + 1;
можно переписать в виде префиксной формы

++х; // Префиксная форма оператора инкремента.
или в виде постфиксной формы:

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

х = 10;

у = ++x;
В этом случае переменная у будет установлена равной 11. Но если в этом коде префиксную форму записи заменить постфиксной, переменная у будет установлена равной 10:

х = 10;

у = x++;
В обоих случаях переменная х получит значение 11. Разница состоит лишь в том, в какой момент она станет равной 11 (до присвоения ее значения переменной у или после). Для программиста очень важно иметь возможность управлять временем выполнения операции инкремента или декремента.
Большинство С++-компиляторов для операций инкремента и декремента создают более эффективный код по сравнению с кодом, сгенерированным при использовании обычного оператора сложения и вычитания единицы. Поэтому профессионалы предпочитают использовать (где это возможно) операторы инкремента и декремента.
Арифметические операторы подчиняются следующему порядку выполнения действий.
Операторы одного уровня старшинства вычисляются компилятором слева направо. Безусловно, для изменения порядка вычислений можно использовать круглые скобки, которые обрабатываются в C++ так же, как практически во всех других языках программирования. Операции или набор операций, заключенных в круглые скобки, приобретают более высокий приоритет по сравнению с другими операциями выражения.
История происхождения имени C++
Теперь, когда вам стало понятно значение оператора «++», можно сделать предположения насчет происхождения имени C++. Как вы знаете, C++ построен на фундаменте языка С, к которому добавлено множество усовершенствований, большинство из которых предназначены для поддержки объектно-ориентированного программирования. Таким образом, C++ представляет собой инкрементное усовершенствование языка С, а результат добавления символов «++» (оператора инкремента) к имени С оказался вполне подходящим именем для нового языка.
Бьерн Страуструп сначала назвал свой язык «С с классами» (С with Classes), но, по предложению Рика Маскитти (Rick Mascitti), он позже изменил это название на C++. И хотя успех нового языка еще только предполагался, принятие нового названия (C++) практически гарантировало ему видное место в истории, поскольку это имя было узнаваемым для каждого С-программиста.
Операторы отношений и логические операторы
Операторы отношений и логические (булевы) операторы, которые часто идут «рука об руку», используются для получения результатов в виде значений ИСТИНА/ЛОЖЬ. Операторы отношений оценивают по «двубалльной системе» отношения между двумя значениями, а логические определяют различные способы сочетания истинных и ложных значений. Поскольку операторы отношений генерируют ИСТИНА/ЛОЖЬ-результаты, то они часто выполняются с логическими операторами. Поэтому мы и рассматриваем их в одном разделе.
Операторы отношений и логические (булевы) операторы перечислены в табл. 3.6. Обратите внимание на то, что в языке C++ в качестве оператора отношения «не равно» используется символ «!=», а для оператора «равно» — двойной символ равенства (==). Согласно стандарту C++ результат выполнения операторов отношений и логических операторов имеет тип bool, т.е. при выполнении операций отношений и логических операций получаются значения true или false. При использовании более старых компиляторов результаты выполнения этих операций имели тип int (нуль или ненулевое целое, например 1). Это различие в интерпретации значений имеет в основном теоретическую основу, поскольку C++ автоматически преобразует значение true в 1, а значение false — в 0, и наоборот.
Операнды, участвующие в операциях «выяснения» отношений, могут иметь практически любой тип, главное, чтобы их можно было сравнивать. Что касается логических операторов, то их операнды должны иметь тип bool, и результат логической операции всегда будет иметь тип bool. Поскольку в C++ любое ненулевое число оценивается как истинное (true), а нуль эквивалентен ложному значению (false), то логические операторы можно использовать в любом выражении, которое дает нулевой или ненулевой результат.
Помните, что в C++ любое ненулевое число оценивается как true, а нуль— как false.
Логические операторы используются для поддержки базовых логических операций И, ИЛИ и НЕ в соответствии со следующей таблицей истинности. Здесь 1 используется как значение ИСТИНА, а 0 — как значение ЛОЖЬ.
Несмотря на то что C++ не содержит встроенный логический оператор «исключающее ИЛИ» (XOR), его нетрудно «создать» на основе встроенных. Посмотрите, как следующая функция использует операторы И, ИЛИ и НЕ для выполнения операции «исключающее ИЛИ».

bool хоr (bool a, bool b)

{

return (а || b) && !(а && b);

}
Эта функция используется в следующей программе. Она отображает результаты применения операторов И, ИЛИ и «исключающее ИЛИ» к вводимым вами же значениям. (Помните, что здесь единица будет обработана как значение true, а нуль — как false.)

// Эта программа демонстрирует использование функции хоr ().

#include <iostream>

using namespace std;

bool хоr (bool a, bool b);

int main ()

{

bool p, q;

cout << "Введите P (0 или 1): ";

cin >> p;

cout << "Введите Q (0 или 1): ";

cin >> q;

cout << "P И Q: " << (p && q) << ' \n';

cout << "P ИЛИ Q: " << (p || q) << ' \n';

cout << "P XOR Q: " << xor (p, q) << '\n';

return 0;

}

bool хоr (bool a, bool b)

{

return (a || b) && !(a && b);

}
Вот как выглядит возможный результат выполнения этой программы.
Введите Р (0 или 1): 1
Введите Q (0 или 1): 1
Р И Q: 1
Р ИЛИ Q: 1
Р XOR Q: 0
В этой программе обратите внимание вот на что. Хотя параметры функции xor () указаны с типом bool, пользователем вводятся целочисленные значения (0 или 1). В этом ничего нет странного, поскольку C++ автоматически преобразует число 1 в true, а 0 в false. И наоборот, при выводе на экран bool-значения, возвращаемого функцией xor (), оно автоматически преобразуется в число 0 или 1 (в зависимости от того, какое значение «вернулось»: false или true). Интересно отметить, что, если типы параметров функции хоr () и тип возвращаемого ею значения заменить типом int, эта функция будет работать абсолютно так же. Причина проста: все дело в автоматических преобразованиях, выполняемых С++-компилятором между целочисленными и булевыми значениями.
Как операторы отношений, так и логические операторы имеют более низкий приоритет по сравнению с арифметическими операторами. Это означает, что такое выражение, как 10 > 1+12 будет вычислено так, как если бы оно было записано в таком виде: 10 >(1 + 12)
Результат этого выражения, конечно же, равен значению ЛОЖЬ. Кроме того, взгляните еще раз на инструкции вывода результатов работы предыдущей программы на экран.

cout << "Р И Q: " << (р && q) << '\n';

cout << "Р ИЛИ Q: " << (р | | q) << '\n';
Без круглых скобок, в которые заключены выражения р && q и р || q, здесь обойтись нельзя, поскольку операторы && и || имеют более низкий приоритет, чем оператор вывода данных.
С помощью логических операторов можно объединить в одном выражении любое количество операций отношений. Например, в этом выражении объединено сразу три операции отношений.

var>15 || !(10<count) && 3<=item
Приоритет операторов отношений и логических операторов показан в следующей таблице.
Выражения
Операторы, литералы и переменные — это все составляющие выражений. Вероятно, вы уже знакомы с выражениями по предыдущему опыту программирования или из школьного курса алгебры. В следующих разделах мы рассмотрим аспекты выражений, которые касаются их использования в языке C++.
Преобразование типов в выражениях
Если в выражении смешаны различные типы литералов и переменных, компилятор преобразует их к одному типу. Во-первых, все char- и short int-значения автоматически преобразуются (с расширением «типоразмера») к типу int. Этот процесс называется целочисленным расширением (integral promotion). Во-вторых, все операнды преобразуются (также с расширением «типоразмера») к типу самого большого операнда. Этот процесс называется расширением типа (type promotion), причем он выполняется по операционно. Например, если один операнд имеет тип int, а другой — long int, то тип int расширяется в тип long int. Или, если хотя бы один из операндов имеет тип double, любой другой операнд приводится к типу double. Это означает, что такие преобразования, как из типа char в тип double, вполне допустимы. После преобразования оба операнда будут иметь один и тот же тип, а результат операции — тип, совпадающий с типом операндов.
Рассмотрим, например, преобразование типов, схематически представленное на рис. 3.1. Сначала символ ch подвергается процессу «расширения» типа и преобразуется в значение типа int. Затем результат операции ch/i приводится к типу double, поскольку результат произведения f*d имеет тип double. Результат всего выражения получит тип double, поскольку к моменту его вычисления оба операнда будут иметь тип double.
Преобразования, связанные с типом bool
Как упоминалось выше, значения типа bool автоматически преобразуются в целые числа 0 или 1 при использовании в выражении целочисленного типа. При преобразовании целочисленного результата в тип bool нуль преобразуется в false, а ненулевое значение — в true. И хотя тип bool относительно недавно был добавлен в язык C++, выполнение автоматических преобразований, связанных с типом bool, означает, что его введение в C++ не имеет негативных последствий для кода, написанного для более ранних версий C++. Более того, автоматические преобразования позволяют C++ поддерживать исходное определение значений ЛОЖЬ и ИСТИНА в виде нуля и ненулевого значения. Таким образом, тип bool очень удобен для программиста.
Приведение типов
В C++ предусмотрена возможность установить для выражения заданный тип. Для этого используется операция приведения типов (cast). C++ определяет пять видов таких операций. В этом разделе мы рассмотрим только один из них, а остальные четыре описаны ниже в этой книге (после темы создания объектов). Итак, общий формат операции приведения типов таков:

(тип) выражение
Здесь элемент тип означает тип, к которому необходимо привести выражение. Например, если вы хотите, чтобы выражение х/2 имело тип float, необходимо написать следующее:

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

#include <iostream>

using namespace std;

int main () /* Выводим i и значение i/2 с дробной частью.*/

{

int i;

for (i=1; i<=100; ++i )

cout << i << "/ 2 равно: " << (float) i / 2 << '\n';

return 0;

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

х=10/у*(127/х);

х = 10 / у * (127/х);
Круглые скобки (так же, как в алгебре) повышают приоритет операций, содержащихся внутри них. Использование избыточных или дополнительных круглых скобок не приведет к ошибке или замедлению вычисления выражения. Другими словами, от них не будет никакого вреда, но зато сколько пользы! Ведь они помогут прояснить (для вас самих в первую очередь, не говоря уже о тех, кому придется разбираться в этом без вас) точный порядок вычислений. Скажите, например, какое из следующих двух выражений легче понять?

х = у/3-34*temp+127;

X = (у/3) — (34*temp) + 127;

Комментирование и размещение ссылок запрещено.

Комментарии закрыты.