Управляющие символьные константы.

Целые Константы

Константы с Плавающей Точкой

Символьные Константы

Строки

Ноль

Const

Перечисления

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

любому значению любого типа можно дать имя и использовать его как константу, добавив к его описанию ключевое слово const;

множество целых констант может быть определено как перечисление;

любое имя вектора или функции является константой.

Целые Константы

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

их десятичные эквиваленты - это 0, 2, 63, 83. В шестнадцатиричной записи эти константы выглядят так:

0x0

0x2

0x3f

0x53

Б уквы a, b, c, d, e и f, или их эквиваленты в верхнем регистре, используются для представления чисел 10, 11. 12, 13, 14 и 15, соответственно. Восьмеричная и шестнадцатиричная записи наиболее полезны для записи набора битов; применение этих записей для выражения обычных чисел может привести к неожиданностям. Например, на машине, где int представляется как двоичное дополнительное шестнадцатеричное целое, 0xffff является отрицательным десятичным числом -1; если бы для представления целого использовалось большее число битов, то оно было бы числом 65535.

Константы с Плавающей Точкой

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

1.23 .23 0.23 1. 1.0 1.2e10 1.23e-15

З аметьте, что в середине константы с плавающей точкой не может встречаться пробел. Например, 65.43 e-21 является не константой с плавающей точкой, а четырьмя отдельными лексическими символами (лексемами):

65.43 e - 21

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

Const float pi = 3.14159265;

Символьные Константы

Х отя в C++ и нет отдельного символьного типа данных, точнее, символ может храниться в целом типе, в нем для символов имеется специальная и удобная запись. Символьная константа - это символ, заключенный в одинарные кавычки; например, "a" или "0". Такие символьные константы в действительности являются символическими константами для целого значения символов в наборе символов той машины, на которой будет выполняться программа (который не обязательно совпадает с набором символов, применяемом на том компьютере, где программа компилируется). Поэтому, если вы выполняетесь на машине, использующей набор символов ASCII, то значением "0" будет 48, но если ваша машина использует EBCDIC, то оно будет 240. Употребление символьных констант вместо десятичной записи делает программу более переносимой. Несколько символов также имеют стандартные имена, в которых обратная косая \\ используется как escape-символ:

В опреки их внешнему виду каждое является одним символом. Можно также представлять символ одно-, дву- или трехзначным восьмеричным числом (символ \\, за которым идут восьмеричные цифры), или одно-, дву- или трехзначным шестнадцатиричным числом (\\x, за которым идут шестнадцатиричные цифры). Например:

"\\6" "\\x6" 6 ASCII ack
"\\60" "\\x30" 48 ASCII "0"
"\\137" "\\x05f" 95 ASCII "_"

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

Строки

С троковая константа - это последовательность символов, заключенная в двойные кавычки:

"это строка"

К аждая строковая константа содержит на один символ больше, чем кажется; все они заканчиваются пустым символом "\\0" со значением 0.

Например:

Sizeof("asdf")==5;

С трока имеет тип "вектор из соответствующего числа символов", поэтому "asdf" имеет тип char. Пустая строка записывается "" (и имеет тип char). Заметьте, что для каждой строки s strlen(s)==sizeof(s)-1, поскольку strlen() не учитывает завершающий 0.
Соглашение о представлении неграфических символов с обратной косой можно использовать также и внутри строки. Это дает возможность представлять в строке двойные кавычки и escape-символ \\. Самым обычным символом этого рода является, безусловно, символ новой строки "\\n".

Например:

Cout << "гудок в конце сообщения\\007\\n"

Где 7 - значение ASKII символа bel (звонок).

В строке невозможно иметь "настоящую" новую строку:

"это не строка,
а синтаксическая ошибка"

О днако в строке может стоять обратная косая, сразу после которой идет новая строка; и то, и другое будет проигнорировано.

Например:

Cout << "здесь все \\
ok"

Напечатает

Здесь все ok

Н овая строка, перед которой идет escape (обратная косая), не приводит к появлению в строке новой строки, это просто договоренность о записи.

В строке можно иметь пустой символ, но большинство программ не будет предполагать, что есть символы после него. Например, строка "asdf\\000hjkl" будет рассматриваться стандартными функциями, вроде strcpy() и strlen(), как "asdf".

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

Char v1 = "a\\x0fah\\0129"; // "a" "\\xfa" "h" "\\12" "9"
char v2 = "a\\xfah\\129"; // "a" "\\xfa" "h" "\\12" "9"
char v3 = "a\\xfad\\127"; // "a" "\\xfad" "\\127"

И мейте в виду, что двузначной шестнадцатиричной записи на машинах с 9-битовым байтом будет недостаточно.

Ноль

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

Const

К лючевое слово const может добавляться к описанию объекта, чтобы сделать этот объект константой, а не переменной.

Например:

Const int model = 145;
const int v = { 1, 2, 3, 4 };

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

Model = 145; // ошибка
model++; // ошибка

З аметьте, что const изменяет тип, то есть ограничивает способ использования объекта, вместо того, чтобы задавать способ размещения константы. Поэтому например вполне разумно, а иногда и полезно, описывать функцию как возвращающую const:

Const char* peek(int i)
{
return private[i];
}

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

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

И спользование указателя вовлекает два объекта: сам указатель и указываемый объект. Снабжение описания указателя "префиксом" const делает объект, но не сам указатель, константой.

Например:

Const char* pc = "asdf"; // указатель на константу
pc = "a"; // ошибка
pc = "ghjk"; // ok

Ч тобы описать сам указатель, а не указываемый объект, как константный, используется операция const*.

Например:

Char *const cp = "asdf"; // константный указатель
cp = "a"; // ok
cp = "ghjk"; // ошибка

Ч тобы сделать константами оба объекта, их оба нужно описать const.

Например:

Const char *const cpc = "asdf"; // const указатель на const
cpc = "a"; // ошибка
cpc = "ghjk"; // ошибка

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

Например:

Char* strcpy(char* p, const char* q); // не может изменить q

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

Например:

Int a = 1;
const c = 2;
const* p1 = &c; // ok
const* p2 = &a; // ok
int* p3 = &c; // ошибка
*p3 = 7; // меняет значение c

К ак обычно, если тип в описании опущен, то он предполагается int.

Перечисления

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

Например:

Enum { ASM, AUTO, BREAK };

Определяет три целых константы, называемы перечислителями, и присваивает им значения. Поскольку значения перечислителей по умолчанию присваиваются начиная с 0 в порядке возрастания, это эквивалентно записи:

Const ASM = 0;
const AUTO = 1;
const BREAK = 2;

П еречисление может быть именованным.

Например:

Enum keyword { ASM, AUTO, BREAK };

И мя перечисления становится синонимом int, а не новым типом. Описание переменной keyword, а не просто int, может дать как программисту, так и компилятору подсказку о том, что использование преднамеренное.

Например:

Keyword key;
switch (key) {
case ASM:
// что-то делает
break;
case BREAK:
// что-то делает
break;
}

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

М ожно также задавать значения перечислителей явно.

Например:

Enum int16 {
sign=0100000, // знак
most_significant=040000, // самый значимый
least_significant=1 // наименее значимый
};

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

Символьная константа - это последовательность из одной или нескольких символов, заключенная в одиночные кавычки (например "x" ). Если внутри одиночных кавычек расположен один символ, значением константы является числовое значение этого символа в кодировке, принятой на данной машине. Значение константы с несколькими символами зависит от реализации.

Символьная константа не может содержать в себе одиночную кавычку " или символ новой строки; чтобы изобразить их и некоторые другие символы, могут быть использованы эскейп-последовательности :

Эскейп-последовательность \ooo состоит из обратной наклонной черты, за которой следуют одна, две или три восьмеричные цифры, специфицирующие значение желаемого символа. Наиболее частым примером такой конструкции является \0 (за которой не следует цифра); она специфицирует NULL-символ. Эскейп-последовательность \xhh состоит из обратной наклонной черты с буквой x , за которыми следуют шестнадцатеричные цифры, специфицирующие значение желаемого символа. На количество цифр нет ограничений, но результат будет не определен, если значение полученного символа превысит значение самого "большого" из допустимых символов. Если в данной реализации тип char трактуется как число со знаком, то значение и в восьмеричной, и в шестнадцатеричной эскейп-последовательности получается с помощью "распространения знака", как если бы выполнялась операция приведения к типу char . Если за \ не следует ни один из перечисленных выше символов, результат не определен.

В некоторых реализациях имеется расширенный набор символов, который не может быть охвачен типом char . Константа для такого набора пишется с буквой L впереди (например L"x") и называется расширенной символьной константой. Такая константа имеет тип wchar_t (целочисленный тип, определенный в стандартном заголовочном файле ). Как и в случае обычных символьных констант, здесь также возможны восьмеричные и шестнадцатеричные эскейп- последовательности; если специфицированное значение превысит тип wchar_t , результат будет не определен.

Некоторые из приведенных эскейп-последовательностей новые (шестнадцатеричные в частности). Новым является и расширенный тип для символов. Наборам символов, обычно используемым в Америке и Западной Европе, подходит тип char , а тип wchar_t был добавлен главным образом для азиатских языков.

А2.5.3. Константы с плавающей точкой

Константа с плавающей точкой состоит из целой части, десятичной точки, дробной части, e или E и целого (возможно, со знаком), представляющего порядок, и, возможно, суффикса типа, задаваемого одной из букв: f , F , l или L . И целая, и дробная часть представляют собой последовательность цифр. Либо целая часть, либо дробная часть (но не обе вместе) могут отсутствовать; также могут отсутствовать десятичная точка или E с порядком (но не обе одновременно). Тип определяется суффиксом: F или f определяют тип float , L или l - тип long double ; при отсутствии суффикса подразумевается тип double .

Суффиксы для констант с плавающей точкой являются нововведением.

A2.5.4. Константы-перечисления

Идентификаторы, объявленные как элементы перечисления (A8.4), являются константами типа int .

A2.6. Строковые литералы

Строковый литерал, который также называют строковой константой, - это последовательность символов, заключенная в двойные кавычки (Например, "..."). Строка имеет тип "массив символов" и память класса static (A4), которая инициализируется заданными символами. Представляются ли одинаковые строковые литералы одной копией или несколькими, зависит от реализации. Поведение программы, пытающейся изменить строковый литерал, не определено.

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

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

То, что строковые литералы не обязательно представляются разными копиями, запрет на их модификацию, а также конкатенация соседних строковых литералов - нововведения ANSI-стандарта. "Расширенные" строковые литералы также объявлены впервые.

A3. Нотация синтаксиса

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

{ выражение необ }

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

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

A4. Что обозначают идентификаторы

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

A4.1. Класс памяти

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

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

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

A4.2. Базовые типы

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

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

Беззнаковые символы, объявленные с помощью слов unsigned char , имеют ту же разрядность, что и обычные символы, но представляют неотрицательные значения; с помощью слов signed char можно явно объявить символы со знаком, которые занимают столько же места, как и обычные символы.

Тип unsigned char не упоминался в первой редакции языка, но всеми использовался. Тип signed char - новый.

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

Для беззнаковых целых в объявлениях используется ключевое слово unsigned . Такие целые подчиняются арифметике по модулю 2 в степени n , где n - число битов в представлении числа, и, следовательно, в арифметике с беззнаковыми целыми никогда не бывает переполнения. Множество неотрицательных значений, которые могут храниться в объектах со знаком, является подмножеством значений, которые могут храниться в соответствующих объектах без знака; знаковое и беззнаковое представления каждого такого значения совпадают. Любые два из типов с плавающей точкой: с одинарной точностью (float ), с двойной точностью (double ) и с повышенной точностью (long double ) могут быть синонимами, но каждый следующий тип этого списка должен по крайней мере обеспечивать точность предыдущего.

long double - новый тип. В первой редакции языка синонимом для double был long float , теперь последний изъят из обращения.

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

Поскольку объекты перечислений можно рассматривать как числа, перечисление относится к арифметическому типу. Типы char и int всех размеров, каждый из которых может быть со знаком или без знака, а также перечисления называют целочисленными (integral ) типами. Типы float , double и long double называются типами с плавающей точкой .

Тип void специфицирует пустое множество значений. Он используется как "тип возвращаемого функцией значения" в том случае, когда она не генерирует никакого результирующего значения.

A4.3. Производные типы

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

· массивы объектов заданного типа;

· функции , возвращающие объекты заданного типа;

· указатели на объекты заданного типа;

· структуры , содержащие последовательность объектов, возможно, различных заданных типов;

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

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

A4.4. Квалификаторы типов

Тип объекта может снабжаться квалификатором. Объявление объекта с квалификатором const указывает на то, что его значение далее не будет изменяться; объявляя объект как volatile (изменчивый, непостоянный (англ. )), мы указываем на его особые свойства для выполняемой компилятором оптимизации. Ни один из квалификаторов на диапазоны значений и арифметические свойства объектов не влияет. Квалификаторы обсуждаются в A8.2.

A5. Объекты и Lvalues

Объект - это некоторая именованная область памяти; lvalue - это выражение, обозначающее объект. Очевидным примером lvalue является идентификатор с соответствующим типом и классом памяти. Существуют операции, порождающие lvalue . Например, если E - выражение типа указатель, то *E есть выражение для lvalue , обозначающего объект, на который указывает E . Термин "lvalue " произошел от записи присваивания E1 = E2, в которой левый (left - левый (англ. ), отсюда буква l , value - значение) операнд E1 должен быть выражением lvalue . Описывая каждый оператор, мы сообщаем, ожидает ли он lvalue в качестве операндов и выдает ли lvalue в качестве результата.

A6. Преобразования

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

Лабораторная работа №1

Знакомство с языком программирования С++

Цель работы:

1. Изучение интерфейса программной оболочки Visual C++;

2. Компиляция и создание исполняемых файлов.

3. Изучение основных типов данных языка С++;

Базовые типы данных;

Переменные и константы;

4. Изучение операторов:

Арифметических;

Логических;

Сравнения;

Побитовых;

Ввода и вывода.

5. Приобретение навыков работы в ИСП Microsoft Visual C++ 5.0.

Используемое оборудование:

Персональная ЭВМ, совместимая с IBM PC.

Используемое программное обеспечение:

Операционная система Windows;

Интегрированная среда программирования Microsoft Visual C++ 5.0 (ИСП Microsoft Visual C++ 5.0).

Задание по работе

1.1. Загрузить ИСП Microsoft Visual C++ 5.0.

1.2. Изучить команды ИСП Microsoft Visual C++ 5.0.

1.3. Изучить основные типы данных ИСП Microsoft Visual C++ 5.0.

1.4. Выполнить пример 1, пример 2, пример 3 и задание преподавателя.

1.5. Записать протокол работы с интегрированной средой.

Порядок выполнения работы

2.1. Запустить Microsoft Visual C++ 5.0.

2.2. Создать *.cpp файл в рабочем каталоге.

2.3. Выполнить пример 1, пример 2, пример 3 и задание преподавателя.

2.4. Составить схему алгоритма и написать программу (по заданию преподавателя). Записать протокол работы с интегрированной средой.

2.5. Закончить работу с Microsoft Visual C++ 5.0 и запустить программу.

3.1. Наименование лабораторной работы.

3.2. Цель работы.

3.3. Теоретическую часть.

3.4. Алгоритмы выполненных программ.

3.5. Текст выполненных программ.

3.6. Вывод.

Краткое описание работы

4.1. Запуск и работа в ИСП Microsoft Visual C++ 5.0.

Для запуска ИСП Microsoft Visual C++ 5.0 необходимо запустить меню Пуск - Microsoft Visual C++ 5.0 - Microsoft Visual C++ 5.0.

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

Ø Запустить Visual C++ (Пуск®Программы® Microsoft Visual C++ 5.0.® Microsoft Visual C++ 5.0. );

Ø Выбрать "New" в меню "File". Проверить, что бы в диалоговой панеле "New" была выбрана закладка "Projects". В списке типов проектов выберите "Win32 Console Application";

Ø Выбрать каталог для проекта ‘Location’ (С:\students\’группа*) и имя проекта ‘Project name’, например, "First" и нажмите кнопку "OK". У вас создадутся "First classes";

Ø После этого выберите опять "New", но с закладкой "Files" и выберите "C++ Source File". В списке ‘File name’ задайте имя например, "First" Далее нажмите "OK" и создастся файл "First.cpp".

Общая структура программы.

Наша задача – рассмотреть общую структуру программы написанной на языке С/С++, то есть весь исходный текст размещается в одном файле:

Ø Область директив препроцессора (include, define..);

Ø Описание пользовательских типов данных;

Ø Неполные объявления функций;

Ø Описание глобальных переменных;

Ø Объявление функции 1;

Ø Объявление функции 2;

Ø Объявление функции main().

Данная схема не имеет такого жесткого порядка как в Паскале, однако, она считается традиционной.

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

Минимальная программа выглядит следующим образом:

Void main(void)

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

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

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

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

Вывод строки на экран

Прежде всего, давайте напишем программу, выводящую строку на экран.

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

Пример 1:

// Первая программа на С++

#include

Void main ()

cout << “Thise is my first program\n” << endl;

Для того, чтобы выполнить программу надо ее вначале сохранить. Зайдите в меню File и там нажмите на Save All . Затем надо ее построить (скомпилировать) для этого нужно выполнить следующие действия:

Ø Зайдем в меню (Build®Build *.exe) или сочетание клавиш (F7), начнется построение программы. Если компилятор не выдал сообщение об ошибке, которые можно посмотреть в появившемся внизу окошке, то можно смело запускать программу;

Ø Теперь вам осталось только выполнить программу, для этого зайдите в меню (Build®Execute *.exe.) или сочетание клавиш (Ctrl+F5);

Ø Ваша программа запущенна.

Строка #include сообщает компилятору, чтобы он включил стандартные возможности потока ввода и вывода, находящиеся в файле iostream.h. Без этих описаний выражение cout << "Thise is my first program " не имело бы смысла. Основные стандартные библиотеки приведены в таблице 1.

Таблица 1.

Основные стандартные библиотеки С/С++

Операция << ("поместить в") пишет свой первый аргумент во второй (в данном случае, строку "Thise is my first program " в стандартный поток вывода cout). Строка – это последовательность символов, заключенная в двойные кавычки. В строке символ обратной косой \, за которым следует другой символ, обозначает один специальный символ; в данном случае, \n является символом новой строки. Таким образом, выводимые символы состоят из "Thise is my first program " и перевода строки, которые определяют функцию, названную main . Каждая программа должна содержать функцию с именем main , и работа программы начинается с выполнения этой функции.

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

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

Пример 2:

#include

Void main()

int inch = 0; // inch - дюйм

cout << "inches";

cin >> inch;

cout << inch;

cout << " in = ";

cout << inch*2.54;

cout << " cm\n";

Первая строка функции main() описывает целую переменную inch . Ее значение считывается с помощью операции >> ("взять из") над стандартным потоком ввода cin .

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

cout << inch << " in = " << inch*2.54 << " cm\n";

Комментарии

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

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

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

4.6. Типы данных в C++

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

Ø Численные знаковые целые (int, short, char);

Ø Численные знаковые дробные (float, double, long (в С), long double (в С);

Ø Численные без знаковые - все перечисленные выше типы с добавлением Unsigned;

Ø Char так же может использоваться как символьный тип .

Стандартные типы и размеры соответствующих ячеек приведены ниже.

Диапазон	Размер (Бт)
char -128..127;
unsigned char 0..255;
int -32 768.. 32 767;
unsigned int 0..65535;
long -2 147 483 648..2 147 483 647;
unsigned long 0..4 294 967 295;
float 3.4e-38..3.4e+38;
double 1.7e-308..1.7e+308;
long double 3.4e-4932..3.4e+4932.

Переменная в C/C++ объявляется следующим образом:

Int iMyVariable;

В приведенном операторе iMyVariable объявлена как целая переменная. А вот объявление переменной типа char :

Char cMyChar;

Такие типы данных, как int , float , char и long , являются неотъемлемой частью C/C++ и вам не нужно писать никакого кода, чтобы сообщить компилятору о том, что означают эти слова. C/C++ позволяет вам также объявлять свои собственные, специальные типы данных.

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

#include

Void main(void)

cout << " (unsigned)int = " << sizeof(int) << endl;

cout << " (unsigned)short = " << sizeof(short) << endl;

cout << " (unsigned)char = " << sizeof(char) << endl;

cout << " (unsigned)float = " << sizeof(float) << endl;

cout << " (unsigned)double = " << sizeof(double) << endl;

cout << " (unsigned)long = " << sizeof(long) << endl;

cout << " (unsigned)long double = " << sizeof(long double) << endl;

Для того, чтобы узнать размер ячейки соответствующего типа достаточно написать в программе sizeof (тип). Дело в том, что для различных операционных систем размеры ячейки одного типа может отличаться (например тип int в 16-ти и 32-х разрядных ОС, 1 байт и 2 байта соответственно).

Оператор sizeof вычисляет размер своего операнда в байтах. Операнд должен быть или выражением, которое не вычисляется, или именем типа в скобках. Оператору sizeof нельзя применять к функции, битовому полю, неопределенному классу, типу void или к массиву с неуказанными границами индексов. Байт никак не определяется языком, кроме как результата операции sizeof , именно sizeof (char) есть 1.

4.7. Переменные

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

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

Переменная - это именованная область памяти, значение которой может изменяться в процессе выполнения программы.

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

Если объявление располагается внутри пары фигурных скобок (например, внутри тела функции), то объявленные переменные считаются локальными и память для них отводится в области стека программы, а начальное значение неопределенно.

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

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

В языке С++ существуют два классификатора, управляющих доступом и модификацией: const и volatile .

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

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

В языке С/С++ предусмотрены управляющие символьные константы , которые приведены в таблице 2.

Таблица 2.

Управляющие символьные константы

Самые знаменитые служебные символы: перевод строки (код 13), возврат каретки (код 10), табуляция (код 9). Для задания их в программе в виде символьных констант используется сочетание двух видимых символов, а именно “\n”, “\r”, “\t” соответственно. Для представления символа “слэш“ используется конструкция “\\”

В языке С существуют четыре спецификатора хранения: extern, static, register, auto.

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

Похожая информация.

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

Примеры:

“1234567890”

“\t состав президиума”

“начало строки \t и конец строки”.

В качестве терминирующего символа выбран символ с кодом 0 (не путайте его с символом "0"). Таким образом, определение

char HelloStr = "Hello, world";

фактически интерпретируется как

char HelloStr = {"H", "e", "l", "l", "o", " ", ",", "w", "o", "r", "l", "d", "\0"};

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

printf ("Hello, world\n");

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

char str1 = "Hello, world\n";

При размещении строки в памяти транслятор автоматически добавляет в ее конец символ ‘\0’, т.е. нулевой байт.

Количество элементов в таком массиве на 1 больше, чем в изображении соответствующей строковой константы, т.к. в конец строки добавили нулевой байт ‘\0’.

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

Присвоить значение массиву символов (т.е. строке) с помощью обычного оператора присваивания нельзя. Поместить строку в массив можно либо с помощью инициализации (при определении символьного массива), либо с помощью функций ввода. В функции scanf () или printf () для символьных строк используется спецификация преобразования % s .

Пример:

/*печать символьной строки*/

#include

{ char B=”Cезам, откройся!”;

printf(“%s”,B); } /*конец программы*/

Результат выполнения программы: Сезам, откройся!

В программе длина массива В – 17 элементов, т.е. длина строки, помещаемой в массив (16 символов), плюс нулевой байт окончания строки. Именно 17 байтов выделяется при инициализации массива в приведенном примере. Инициализация массива символов с помощью строковой константы представляет собой сокращенный вариант инициализации массива и введена в язык для упрощения. Можно воспользоваться обычной инициализацией, поместив начальные значения элементов массива в фигурные скобки и не забыв при этом поместить в конце списка начальных значений специальный символ окончания строки ‘\0’. Таким образом, в программе была допустима такая инициализация массива В:

char B = {‘C’,’е’,’з’,’а’,’м’,’,’,’ ’,’о’,’т’,’к’,’р’,’о’,’й’,’с’,’я’,’!’,’\0’};

Как вводить строки или выводить их на экран?

Выводиться строка может или уже известной вам функцией printf() со спецификатором ввода "%s ", либо специальной функцией int puts (char *string), которая выводит строку string на экран и возвращает некоторое ненулевое значение в случае успеха.

Зачем нужен спецификатор "%s "? Это делается для того, чтобы можно было выводить строки с любыми символами. Сравните:

Пример:

char str = "Захотелось мне вывести %d...";

printf ("%s", str); /* Правильный вариант */

printf ("\n"); /* Разделитель новой строки */

printf (str); /* Неправильный вариант */

В первом случае функция напечатает именно то, что от нее требуется. А вот во втором случае printf() , встретив в строке str спецификатор "%d" (ведь теперь эта строка – первая, значит, она задает формат вывода), сделает вывод, что за ней должно следовать число. А так как оно не следует, то вместо "%d " будет напечатан некоторый мусор – число, находящееся в тот момент в стеке.

Последствия могут быть и более серьезными, если в строке находится последовательность "%s", то сочтет ее за строку, и будет выводить ее до тех пор, пока не встретит нулевой символ. А где она его встретит, сколько успеет напечатать и не crash"нется ли из-за обращения не к своей памяти – не знает никто.

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

/*чтение строки с терминала*/

int getline(char s , / *введенная строка*/

int lim) /*ее максимальная длина*/

{ int c, i; /* с – вводимый символ*/

for (i=0; i

s[i] = ’\0’;

Ввод–вывод строк. Основные функции работы со строками

Одной из наиболее популярных операций ввода-вывода является операция ввода-вывода строки символов. В библиотеку языка СИ для обмена данными через стандартные потоки ввода-вывода включены функции ввода-вывода строк gets () и puts (), которые удобно использовать при создании диалоговых систем.

Для ввода строки существует функция с прототипом

char *gets (char *string),

которая считывает строку с клавиатуры и помещает ее в буфер string , указатель на который и возвращает. Если произошла ошибка, то возвращается EOF.

Функция имеет только один аргумент – указатель s < stdio . h >.

Функция gets() завершает свою работу при вводе символа ‘\ n ’ , который автоматически передается с клавиатуры в ЭВМ при нажатии клавиши . При этом сам символ ‘\ n ’ во вводимую строку не записывается. Вместо него в строку помещается нуль–символ ‘\0’ . Таким образом, функция gets () производит ввод “правильной” строки , а не просто последовательности символов.

Здесь следует обратить внимание на следующую особенность ввода данных с клавиатуры. Функция gets () начинает обработку информации от клавиатуры только после нажатия клавиши < Enter >. Таким образом, она “ожидает”, пока не будет набрана нужная информация и нажата клавиша <Enter >. Только после этого начинается ввод данных в программу.

Пример: #include

int main (void) {

printf ("Input a string:");

printf ("The string input was: %s\n", string);

Функция puts () (вывод строки на экран) в случае успешного завершения возвращает последний выведенный символ, который всегда является символом ‘\ n " , если произошла ошибка, то возвращается из функции EOF. Прототип этой функции имеет следующий вид:

int puts (char*s); /*функция вывода строки*/

Функция имеет только один аргумент – указатель s на массив символов. Прототип функции описан в файле < stdio . h >.

Приведем простейший пример использования этих функций.

#include

char strl = ”введите фамилию сотрудника:”;

Напомним, что любая строка символов в языке СИ должна заканчиваться нуль–символом ‘\0’ . В последний элемент массива strl нуль–символ будет записан автоматически во время трансляции при инициализации массива. Для функции puts() наличие нуль-символа в конце строки является обязательным.

В противном случае, т.е. при отсутствии в символьном массиве символа ‘\0’ , программа может завершиться аварийно, т.к. функция puts () в поисках нуль-символа будет перебирать всю доступную память байт за байтом, начиная, в нашем примере, с адреса strl . Об этом необходимо помнить, если в программе происходит формирование строки для вывода ее на экран дисплея.

Пример : #include

int main (void) {

char string = "This is an example output string\n";

Функции манипуляции со строками

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

Для манипуляций со строками существует набор функций, объявленных в файле (те, кто пишет под Windows, могут включать вместо него файл <windows.h >).

Наиболее важные функции:

int strcmp (char *string1, char *string2)

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

Пример :

#include

int main (void) {

char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc";

ptr = strcmp (buf2, buf1);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1 \n");

printf("buffer 2 is less than buffer 1 \n");

ptr = strcmp(buf2, buf3);

printf("buffer 2 is greater than buffer 3\n");

printf("buffer 2 is less than buffer 3\n");

На экране появится:

buffer 2 is greater than buffer 1

buffer 2 is less than buffer 3

char *strcpy (char *dest, char *source)

осуществляет копирование строки source на место строки dest . Опять-таки позаботьтесь о том, чтобы вся строка поместилась в отведенном для нее месте. Функция возвращает указатель на строку-приемник.

Пример: #include

#include

int main (void) {

char *str1 = "a b c d e f g h i";

strcpy (string, str1);

printf("%s \n", string);

На экране появится: a b c d e f g h I

char *strcat (char *string1, char *string2)

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

Пример:

#include

int main(void) {

char destination;

char *blank = " ", *c = "C++", *turbo = "Turbo";

strcpy (destination, turbo); //Копирование строки "turbo"

на место destination

strcat (destination, blank); // Склеивание destination …

strcat (destination, c); // сначала с blank , потом с c

printf("%s\n", destination);

На экране появится: Turbo C ++

int strlen (char *string)

возвращает длину строки string (не считая нулевого символа).

char *strdup (char *string)

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

char *strncpy (char *dest, char *source, int count)

char *strncat (char *string1, char *string2, int count)

аналогично strcpy и strcat , но копируются только первые count символов. Функции не добавляют к строке завершающего нуля – вам придется сделать это самим.

char *strchr (char *string, int c)

char *strstr (char *string, char *substring)

ищут первое вхождение в строку string соответственно символа c и подстроки substring . Обе функции возвращают адрес первого вхождения или NULL , если такового не найдено.

Пример :

int main (void) {

char *ptr, c = "r";

//Создаем строку

strcpy (string, "This is a string");

ptr = strchr(string, c);

printf("The character %c is at position: %d\n", c, ptr-string);

printf("The character was not found\n");

До этого момента, все переменные, которые мы рассматривали, были не константами. Их значения можно было изменить в любое время. Например:

int x { 4 }; // инициализация переменной x значением 4 x = 5; // изменяем значение x на 5

Тем не менее, иногда полезно использовать переменные, значения которых нельзя изменить – константы . Вот например, сила тяжести на Земле: 9.8м/с^2. Оно вряд ли поменяется в ближайшее время. Использовать константу для этого случая — наилучший вариант, так как таким способом мы предотвратим любое (даже случайное) изменение значения.

Чтобы сделать переменную константой – используйте ключевое слово const перед типом переменной или после. Например:

const double gravity { 9.8 }; // предпочтительнее использовать const перед типом данных int const sidesInSquare { 4 }; // ок, но не предпочтительно

Несмотря на то, C++ примет const как до, так и после типа, мы рекомендуем использовать именно перед типом.

Константы должны быть инициализированы при объявлении . Их значения с помощью операции присваивания изменить не получится.

const double gravity { 9.8 }; gravity = 9.9; // не допускается - ошибка компиляции

Объявление константы без инициализации также вызовет ошибку компиляции:

const double gravity; // ошибка компиляции, константа должна быть инициализирована

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

std::cout << "Enter your age: "; int age; std::cin >> age; const int usersAge (age); // в дальнейшем переменная usersAge не может быть изменена

const является наиболее полезным (и наиболее часто используемым) с параметрами функций:

void printInteger(const int myValue) { std::cout << myValue; }

void printInteger (const int myValue )

std :: cout << myValue ;

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

Compile time и runtime

Когда вы находитесь в процессе компиляции программы – это compile time (время компиляции ) . Компилятор проверяет вашу программу на синтаксические ошибки, затем конвертирует код в объектные файлы.

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

Constexpr

В C++ есть два вида констант.

Константы r untime . Их значения определяются только во время выполнения (когда программа запущена). Переменные типа usersAge и myValue (в коде выше) — это константы runtime, так как компилятор не может определить их значения во время компиляции. usersAge зависит от пользовательского ввода (который можно получить только во время выполнения программы), а myValue зависит от значения, переданного в функцию (которое станет известным также во время выполнения программы).

Константы c ompile-time . Их значения определяются во время компиляции. Например, сила тяжести Земли – это константа compile-time, мы её определили сами в ходе написания программы.

В большинстве случаев, неважно какой тип константы: compile-time или runtime. Однако, есть все же несколько ситуаций, когда C++ может требовать константу compile-time вместо runtime (например, при определении длины массива фиксированного размера — мы рассмотрим это позже). Так как типов есть два, то компилятору нужно постоянно отслеживать, к какому из них относится какая переменная. Чтобы упростить это задание, в C++ 11 появляется ключевое слово constexpr , которое гарантирует, что тип константы — compile-time:

constexpr double gravity (9.8); // ок, значение определяется во время компиляции constexpr int sum = 4 + 5; // ок, значение 4 + 5 определяется во время компиляции std::cout << "Enter your age: "; int age; std::cin >> age; constexpr int myAge = age; // не ок, переменная age не определяется во время компиляции

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

Правило: Любая переменная, которая не должна изменять свое значение после инициализации — должна быть объявлена, как const (или как constexpr).

Имена констант

Некоторые программисты пишут имена констант заглавными буквами. Другие используют обычные имена, только с префиксом ‘k’. Мы же не будем их как-то выделять, так как константы – это те же обычные переменные, просто с фиксированными значениями, вот и всё. Особой причины, чтобы их выделять нет. Однако, это дело каждого лично.

Символьные константы

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

Плохой способ: Использование макросов-объектов с текстом-заменой в качестве символьных констант

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

В уроке 22 о препроцессорах и директивах , мы говорили, что макросы-объекты имеют две формы – с текстом-заменой и без. Рассмотрим первый случай (с текстом-заменой). Он выглядит так:

#define identifier substitution_text

Как только препроцессор встретит эту директиву, все дальнейшие появления ‘identifier’ будет заменяться на ‘substitution_text’. Идентификатор обычно пишется заглавными буквами с нижним подчеркиванием вместо пробелов.

Например:

int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS;

#define MAX_STUDENTS_PER_CLASS 30

Во время компиляции, препроцессор заменит все идентификаторы MAX_STUDENTS_PER_CLASS на литерал 30.

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

Рассмотрим еще один пример:

#define MAX_STUDENTS_PER_CLASS 30 #define MAX_NAME_LENGTH 30 int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS; setMax(MAX_NAME_LENGTH);

#define MAX_STUDENTS_PER_CLASS 30

#define MAX_NAME_LENGTH 30

int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS ;

setMax (MAX_NAME_LENGTH ) ;

Здесь ясно, что MAX_STUDENTS_PER_CLASS и MAX_NAME_LENGTH имеются в виду как разные объекты, даже если у них одни и те же значения (30).

Так почему же этот способ плохой? Есть две причины.

Во-первых, макросы обрабатываются препроцессором, который заменяет идентификаторы на определенные значения. Эти значения не будут отображаться в отладчике (который показывает ваш фактический код). При компиляции int max_students = numClassrooms * 30; в отладчике вы увидите int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS; . А если нужно будет узнать значение MAX_STUDENTS_PER_CLASS? Вам придется самостоятельно найти его в коде. А это может занять некоторое время, в зависимости от размеров программы.

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

Правило: Не используйте #define для создания символьных констант.

Хороший способ: Переменные const

Лучший способ создать символьную константу — использовать const:

const int maxStudentsPerClass { 30 }; const int maxNameLength { 30 };

const int maxStudentsPerClass { 30 } ;

const int maxNameLength { 30 } ;

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

Правило: Используйте const для создания символьных констант.

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

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

Как это осуществить? Очень просто:

Создайте заголовочный файл для хранения констант.
В заголовочном файле объявите пространство имен (