Программирование в Visual С++ 2005 5 страница

Обратите внимание, что объявление переменной всегда завершается точкой с запятой.

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

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

Таким образом, оператор:

одновременно является и объявлением, и определением. Здесь использовано имя пе-
ременной value, которое объявляется, для доступа к участку компьютерной памяти,
который здесь же определяется, и который может хранить отдельное значение типа
int.

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

Данные, переменные и вычисления 79

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

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

Начальные значения переменных

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

В данном случае value получает значение 0, count — значение 10, a number — зна-
чение 5.

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

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

Фундаментальные типы данных

Разновидность информации, которую может содержать переменная, называется
ее типом данных. Все данные и переменные в вашей программе должны относиться
к определенному типу данных. Стандарт С++ ISO/ANSI предоставляет набор фунда-
ментальных типов данных, специфицированных определенными ключевыми слова-
ми. Фундаментальные типы данных называются так потому, что они хранят значения
типов, представляющих фундаментальные данные на вашем компьютере — по сути,
числовые значения, в которые входят и символы, потому что они представлены чис-
ловыми кодами. Вы уже видели ключевое слово int, применяемое для определения
целочисленных переменных. C++/CLI также определяет фундаментальные типы дан-

80 Глава 2

ных, которые не являются частью ISO/ANSI С++, и позднее в этой главе я расскажу
о них.

Как часть объектно-ориентированных аспектов языка, предусмотрена возмож-
ность определения ваших собственных типов данных, и конечно, разнообразные би-
блиотеки, поставляемые с Visual С++ 2005 также определяют свои типы данных. Но
пока мы ограничимся элементарными числовыми типами данных, представленными
в ISO/ANSI С++. Фундаментальные типы подразделяются на три категории — типы,
содержащие целые числа, типы, содержащие не целочисленные значения, и тип
void, указывающий пустое множество значений или отсутствие типа.

Целочисленные переменные

Как уже говорилось, целочисленные переменные — это переменные, которые со-
держат только значения целых чисел. Количество игроков футбольной команды —
целое число, по крайней мере, в начале игры. Вы уже знаете, что целочисленные
переменные можно объявлять с ключевым словом int. Переменные типа int зани-
мают 4 байта памяти, и могут сохранять как положительные, так и отрицательные
целые значения. Верхний и нижний пределы значений переменных типа int соот-
ветствуют максимальному и минимальному двоичному значению со знаком, которое
может быть представлено 32 битами. Верхний предел переменной типа int — 2³¹ - 1,

что равно 2 147 483 647, а нижний предел------------ (2³¹), что соответствует -2 147 483 648.

Ниже показан пример определения переменной типа int.

В Visual С++ 2005 ключевое слово short также определяет целые переменные, но
занимающие 2 байта в памяти. Ключевое слово short эквивалентно short int, и вы
можете определить две переменных типа short с помощью следующих операторов:

Обе переменных относятся к одному и тому же типу, потому что short означает
то же самое, что short int. Здесь я использовал обе формы названия типа, чтобы
продемонстрировать их применение, но при написании программ лучше ограничи-
ваться одним вариантом, и short встречается более часто.

В С++ также предусмотрен другой целочисленный тип — long, который также
можно записывать как long int. Вот как объявляются переменные типа long:

Эти операторы объявляют переменные bigNumber и largeValue с начальными
значениями 1000000 и 0 соответственно. Буква L, добавленная в конец литералов,
указывает на то, что это — целые типа long. Для той же цели можно также применять
и прописную букву 1, но ее недостаток в том, что ее легко спутать с цифрой 1. Целые
литералы без добавленной буквы L имеют тип int.

При написании больших чисел в программе вы не должны вставлять в них запятые или про-
белы в качестве разделителей групп. В тексте можно написать 12,245,678либо 12 245 678,
но в коде программы следует писать 12345678.

Целочисленные переменные, объявленные как long, в Visual С++ 2005 занимают
4 байта, и могут принимать значения от -2 147 483 648 до 2 147 483 647. Тот же диа-
пазон могут принимать переменные типа int.

Данные, переменные и вычисления 81

В других компиляторах С++ переменные типа long (то же самое, что и тип long
int) могут отличаться от типа int, поэтому, если вы собираетесь компилировать
свои программы в других средах, не полагайтесь на то, что long и int эквивалентны.
При написании действительно переносимого кода вы даже не должны рассчитывать
на то, что int занимает 4 байта (например, в старых 16-разрядных версиях Visual С++
переменные int были двухбайтными).

Символьные типы данных

Тип данных char служит двум целям. Он специфицирует однобайтную пере-
менную, в которой можно сохранять целые числа в пределах определенного диапа-
зона значений, или же код отдельного символа ASCII (American Standard Code for
Information Interchange — американский стандартный код обмена информацией).
Набор кодов символов ASCII приведен в приложении Б. Вы можете объявить пере-
менную char с помощью следующего оператора:

Этот код объявляет переменную по имени letter, инициализированную констан-
той ¹ А¹. Обратите внимание, что значение указывается как отдельный символ в оди-
ночных кавычках, а не в двойных, которые вы использовали ранее для определения
строк символов с целью отображения на экране. Строка символов — это последова-
тельность значений типа char, которая сгруппирована в единое целое, называемое
массивом. Массивы и обработка строк в С++ рассматриваются в главе 4.

Поскольку символ 'А' в кодировке ASCII представлен десятичным значением 65,
вы могли бы написать этот оператор следующим образом:

Это дало бы тот же результат, что и предыдущий оператор. Диапазон целых, которые
могут быть сохранены в переменных типа char, в Visual С++ составляет от -128 до 127.

Обратите внимание, что стандарт ISO/ANSI С++ не требует, чтобы тип char представ-
лял однобайтные целые со знаком. Это выбор реализации компилятора: представлять char
как целые со знаком в диапазоне от-128 до 127либо как целые без знака в диапазоне от 0 до
255. Следует иметь это в виду, если вы собираетесь переносить свой код С++ в другую среду.

Тип wchar_t назван так, поскольку это расширенный символьный тип (wide char
type), и переменные этого типа сохраняют 2-байтные символьные коды со значения-
ми от 0 до 65 535. Ниже показан пример определения переменной типа wchart.

Этот оператор определяет переменную letter, инициализированную 16-битным
кодом буквы Z. Символ L, предшествующий символьной константе ' Z ', сообщает
компилятору, что это 16-битное значение кода символа.

Для инициализации переменных char (как и других целых типов) вы также мо-
жете использовать шестнадцатеричные константы, что во многих случаях удобнее.
Шестнадцатеричное число записывается с применением стандартного представления
шестнадцатеричных цифр: от 0 до 9 и от А до F (или от а до f), означающие в деся-
тичном эквиваленте цифры от 0 до 15. Кроме того, они предваряются сочетанием Ох
(или ОХ) для того, чтобы отличать их от десятичных значений. Таким образом, чтобы
получить тот же результат, вы могли бы переписать оператор, приведенный выше,
следующим образом:

82 Глава 2

Не записывайте десятичные целочисленные значения с ведущим нулем. Компилятор интер-
претирует их как восьмеричные, поэтому значение, записанное как 065, равно 53 в десятич-
ной нотации.

Обратите также внимание, что в Windows ХР имеется утилита Character Map (Таб-
лица символов), которая позволяет находить символы в любых шрифтах, доступных
в Windows. Она показывает коды символов в шестнадцатеричном виде и сообщает,
на какие клавиши нужно нажать для их ввода. Утилиту Character Map можно найти,
если щелкнуть на кнопке Start (Пуск) и заглянуть в папку System Tools (Системные),
находящуюся внутри папки Accessories (Стандартные).

Модификаторы целочисленных типов

Переменные целочисленных типов char, int, short или long сохраняют по умол-
чанию целые значения со знаком (signed), поэтому вы можете применять их как для
хранения положительных, так и отрицательных значений. Это объясняется тем, что
для этих типов по умолчанию принят модификатор типа signed. Поэтому когда вы
пишете int или long, то это означает signed int или signed long соответственно.

Вы также можете использовать ключевое слово signed отдельно для специфика-
ции типа переменной. В этом случае оно означает signed int, например:

Но такое написание не очень распространено, и я предпочитаю применять int,
что выглядит более очевидно.

Диапазон значений, которые могут быть сохранены в переменной типа char, на-
ходится в пределах от -128 до +127, что совпадает с диапазоном допустимых значе-
ний переменных типа short char. Но как это ни прискорбно, тип char и тип signed
char трактуются как разные типы, поэтому вы не должны допускать ошибку, думая,
что это одно и то же.

Если вы уверены, что вам не нужно хранить в переменной отрицательные зна-
чения (например, если собираетесь записывать в нее количество миль, которые вы
проезжаете за рулем в неделю), то вы можете специфицировать переменную как
unsigned:

Минимальное значение, которое можно записать в переменную mileage, равно
нулю, а максимальное — 4 294 967 295 (то есть 2³² - 1). Сравните это с диапазоном
от -2 147 483 648 до 2 147 483 647 для signed long. Один бит, который в перемен-
ных signed служит для указания знака, в unsigned является частью числового значе-
ния. Как следствие, переменные unsigned имеют больший диапазон положительных
значений, но не могут представлять отрицательных. Обратите внимание на букву U
(или и), добавленную к константе unsigned. В предыдущем примере я также добавил
к ней L, чтобы указать, что константа — long. Вы можете использовать эти симво-
лы-модификаторы констант в любом регистре и любой последовательности. Однако
при указании таких значений желательно придерживаться какого-то согласованного
стиля.

Вы также можете применять в качестве спецификатора типа unsigned отдельно,
что подразумевает unsigned int.

Помните, что и signed, и unsigned— ключевые слова, поэтому их нельзя применять в
качестве имен переменных.

Данные, переменные и вычисления 83

Булевский тип

Булевские переменные — это такие переменные, которые могут хранить только
два значения: true и false. Тип таких логических переменных называется bool, по
имени Джорджа Буля (Gerorge Boole), который разработал булеву алгебру. Тип bool
трактуется как целый. Булевские переменные также называют логическими перемен-
ными. Переменные типа bool используются для сохранения результата проверок, ко-
торые могут принимать значения либо "истина" (true), либо "ложь" (false), напри-
мер, как в случае проверки равенства одного значения другому.

Имя переменной типа bool объявляется с помощью следующего оператора:

Конечно, вы можете сразу инициализировать переменные типа bool при их объ-
явлении:

Вы обнаружите, что достаточно часто в коде можно встретить значения TRUE и FALSE
как значения числовых типов — в частности, int. Это наследие тех времен, когда в С++ еще
не был реализован тип bool, и для представления логических значений обычно применялись
переменные типа int. При этом нулевые значения трактовались как "ложь", а ненулевые—
как "истина Символы TRUE и FALSE все еще применяются в MFC, где они представляют
ненулевые целые и 0, соответственно. Обратите внимание, что TRUE и FALSE, записанные
заглавными буквами, не являются ключевыми словами в С++; это просто символы, опреде-
ленные внутри MFC. Помните также, что TRUE и FALSE не являются допустимыми значе-
ниями типа bool, а потому не путайте TRUE и true.

Типы с плавающей точкой

Числовые переменные, не относящиеся к целым, хранятся как числа с плавающей
точкой. Число с плавающей точкой может быть выражено в виде десятичного значе-
ния наподобие 112,5 либо в экспоненциальном виде, таком как 1Д25Е2, где десятич-
ная часть умножается на 10 в степени, указанной после Е (экспонента). Таким обра-
зом, последнее число — это 1Д25х10², что равно 112,5.

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

Вы можете специфицировать переменную с плавающей точкой, используя ключе-
вое слово double, как в следующем операторе:

double in_to__mm = 25.4;

Переменная типа double занимает 8 байт памяти и сохраняет значения, точность
которых определяется примерно 15 десятичными знаками. Диапазон их значений на-
много шире, чем можно выразить 15-ю знаками — начиная от 1,7х10^-308 и заканчивая
1,7х10³⁰⁸, положительные и отрицательные.

Если вам не требуется 15-значная точность и не нужны очень большие диапазоны
значений, которые обеспечивает тип double, можете воспользоваться ключевым сло-
вом float для объявления переменных с плавающей точкой, занимающих 4 байта.

84 Глава 2

Например:

Этот оператор определяет переменную pi с начальным значением 3,14159. Символ
f в конце константы указывает, что она имеет тип float. Без f константа имела бы
тип double. Переменные, объявленные с типом float, имеют точность примерно в
7 десятичных знаков и допускают значения от 3,4х10^-38 до 3,4х10³⁸, положительные и
отрицательные.

Стандарт С++ ISO/ANSI также определяет тип с плавающей точкой long double,
который в Visual С++ 2005 реализован с тем же диапазоном и точностью, что и

double.

Фундаментальные типы ISO/ANSI C++

В табл. 2.1 представлен список всех фундаментальных типов ISO/ANSI С++, а так-
же диапазоны их допустимых значений в Visual С++ 2005.

Литералы

Я уже использовал в этой книге множество явных значений для инициализации
переменных. В С++ фиксированные значения любого рода называются литералами.
Литерал — это значение определенного типа, поэтому 23, 3.14159, 9. 5f и true —
примеры литералов типа int, типа double, типа float и типа bool, соответственно.
Литерал "Samuel Beckett" — это пример строкового литерала, но обсуждение этого
типа мы отложим до главы 4. В табл. 2.2 представлены примеры записи литералов
различных типов.

Вы можете специфицировать литерал как относящийся к типу short или
unsigned short, но компилятор примет начальные значения, являющиеся литера-
лами типа int для переменных этого типа, если значение литерала находится в до-
пустимом диапазоне для типа переменной.

Часто вам нужно будет использовать литералы в процессе вычислений внутри про-
граммы, например, преобразуя значения вроде 12 футов в дюймы, или 25,4 дюймов
в миллиметры, или же для спецификации строк сообщений об ошибках. Однако вы
должны избегать явного применения литералов в программах, когда их смысл не оче-
виден. Вовсе не всем и не всегда ясно, что когда вы указываете значение 2,54, то это
означает число сантиметров в дюйме. Лучше объявить переменную с фиксированным
значением, равным литералу. Например, вы можете назвать ее inchesToCentimeters.
Тогда всякий раз, когда в коде встретится переменная inchesToCentimeters, ее
смысл будет достаточно очевиден. Чуть позже в этой главе вы увидите, как можно за-
фиксировать значение переменной.

Определение синонимов для типов данных

Ключевое слово typedef позволяет определить ваше собственное имя для существу-
ющего типа данных. Используя typedef, вы можете определить имя типа BigOnes как
эквивалент стандартного типа long int, применив следующее объявление:

Это определяет BigOnes как альтернативное имя для long int, поэтому вы сможе-
те объявить переменную mynum типа long int таким объявлением:

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

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

86 Глава 2

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

Переменные с определенным набором значений

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

Этот оператор объявляет тип перечисления по имени Week и переменную thisWeek,
являющуюся экземпляром перечислимого типа Week, которая может принимать толь-
ко константные значения, указанные между фигурными скобками. Если вы попытае-
тесь присвоить thisWeek что-то такое, что не входит в указанный набор, то это вызо-
вет ошибку. Эти символические имена, перечисленные между скобками, называются
перечислителями (enumerators). Фактически каждое из названий дней автоматиче-
ски представляется компилятором как фиксированное целое значение. Первое имя в
списке — Моп — получает значение 0, Tues будет 1 и так далее.

Вы можете присвоить одну из перечисленных констант в качестве значения пере-
менной thisWeek:

Обратите внимание, что вам не нужно квалифицировать перечйслимые констан-
ты именем перечисления. Значение thisWeek будет равно 3, потому что определен-
ным в перечислении символическим константам присваиваются значения типа int
по умолчанию, начиная с 0.

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

Теперь константы перечисления будут равны от 1 до 7. Перечислители даже не
обязаны иметь уникальные значения. Вы можете определить, что и Моп, и Tues долж-
ны, например, иметь значение 1, с помощью следующего оператора:

Поскольку, по сути, типом переменной thisWeek является int, она займет 4 бай-
та, как и все переменные перечислимого типа.

Имея определение перечисления, вы можете определить другую переменную того
же типа:

Это определяет переменную nextWeek как перечисление, которое может прини-
мать значения, специфицированные ранее. Вы даже можете пропустить ключевое

Данные, переменные и вычисления 87

слово enum в объявлении переменной, поэтому предыдущий оператор может быть
переписан так:

При желании вы можете присвоить определенные значения всем перечислите-
лям. Например, можно определить следующее перечисление:

Здесь вы определяете возможные значения переменной things как числовые эк-
виваленты соответствующих символов. Если вы заглянете в таблицу ASCII в приложе-
нии Б, то увидите, что коды этих символов в десятичном виде равны, соответствен-
но, 44, 33 и 63. Как видите, значения перечислителей не обязательно должны идти в
возрастающем порядке. Если вы не специфицируете все значения явно, то каждому
перечислителю, значение которого не задано, будет присвоено значение на единицу
больше предыдущего, как в нашем втором примере Week.

Если нет необходимости объявлять позднее другие переменные перечислимого
типа, вы можете пропустить имя этого типа, например

:

Здесь объявлены три переменных, которые могут принимать значения от Моп
до Sun. Поскольку тип перечислителя не указан, вы не можете позднее сослаться не
него. Обратите внимание, что вообще вы не можете объявлять другие переменные
типа этого перечисления, потому что повторять это определение также не разреша-
ется. Попытка сделать это означала бы, что вы собираетесь переопределить значения
от Моп до Sun, а это недопустимо.

Спецификация типа для перечислимых констант

Перечислимые константы по умолчанию имеют тип int, но вы также можете ука-
зать их тип явно, добавив двоеточие и имя типа для констант вслед за именем типа
перечисления в его объявлении. Тип перечислимых констант может быть знаковым
либо беззнаковым целочисленным типом: short, int, long, char или же bool.

Таким образом, вы можете определить перечисление, представляющее дни неде-
ли, следующим образом:

Здесь константы перечисления будут относиться к типу char, причем первая из
них будет равна 0. Однако, имея константы типа char, вы, вероятно, предпочтете
инициализировать их явно:

Теперь значения констант немного лучше отображают то, что они представляют,
хотя не делают различия между Thursday и Tuesday или между Saturday и Sunday.
Нет никаких проблем в том, что разные константы имеют одно и то же значение, но
имена, конечно, должны быть уникальными.

А вот пример перечисления с константами типа bool:

Поскольку On имеет начальное значение true, то Off будет false. Если бы были
еще указаны последующие константы перечисления, они по умолчанию получили бы
чередующиеся значения.

88 Глава 2

Базовые операции ввода-вывода

Здесь вы только поверхностно ознакомитесь с вводом и выводом в "родном" С++ —
настолько, чтобы использовать его в примерах в процессе дальнейшего изучения
языка. Это совсем не трудно, даже наоборот. А при программировании для Windows
оно и вовсе не понадобится. Ввод и вывод С++ вращается вокруг понятия потоков
данных; данные можно вставлять в выходной поток и принимать из входного. Вы
уже видели, что стандартный выходной поток ISO/ANSI С++ в командную строку на
экране называется cout. Дополняющий его входной поток с клавиатуры известен под
именем cin.

Ввод с клавиатуры

Вы получаете ввод с клавиатуры через поток cin, используя для этого операцию
извлечения из потока». Чтобы прочитать два целых значения с клавиатуры в пере-
менные numl и num2, можно написать следующий оператор:

Дата добавления: 2015-11-04