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

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

 

В С++ используются типизированные именованные константы:

§ для задания параметров, управляющих:
    - размером структур данных  (например, массивов: const int n=10; int mas[n];),
    - числом итераций в циклах (const int k=10; for (int i=1; i<k; i++) ….)

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

§ для обозначения часто встречающихся в программе постоянных величин;

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

 

Например:

int main ()

{const int k = 40;  

int M[ k ][ k ];

float A[ k ], B[ k ][ k ];

……

}

 

Перечисляемые константы

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

enum { one=1, two=2, three=3 }; // one, two, three – условные имена,
                                                //введенные для обозначения констант

enum color { red, yellow, green }; // значения приписываются по умолчанию: red=0, yellow=1,…
                                                  // color – название перечисляемоготипа
enum { red=10, yellow=3, green=4 }; // приписываются указанные значения: red=10 и т.д.

enum { red= 10, yellow=3, green= 10}; // приписываются указанные значения: OK!!!

enum { red= 10, yellow=3, green=red* 10}; // приписываются указанные значения: OK!!!

enum { red=- 2, yellow, green };                    // приписываются указанные значения: OK!!!

 

 

Препроцессорные константы

Препроцессорные константы – также возможный способ определения констант в С++. Для этого используется директива препроцессора #define:

#define IDENTIFICATOR ZAMENA

 

Эта директива вызывает замену в тексте программы каждого появления имени IDENTIFICATOR на текст ZAMENA.

Например:

#define MAX_LEN 100 //в программе имя MAX_LEN заменится на 100

 

С помощью директивы #define можно выполнять «настройку» программы. Например, если в программе предполагается работать с массивом, то его размер можно явно определить на этапе препроцессорной обработки заданием именованного литерала:

исходный текст	результат препроцессорной обработки
#define K 40 void main () {int M[K] [K]; float A[K], B[K] [K]; …….	void main () {int M[40] [40]; float A[40], B[40] [40];

 

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

 

Обратите внимание на особенности работы с константами:

1.

 const int i = 7;       // целая константа

 //         i = 9;        неверно, значение константы не должно изменяться

 

// const int j;             неверно, отсутствует начальное значение константы

const int k(4);       // верно, целая константа

 

2. Примеры определений символьной константы:

const char c='1';

const char d=49;      // 49 – это код ‘1’ в 10-ичной с/с

const char dd= 0 61;    // 61 – это код ‘1’ в 8 -ичной с/с

const char ddd= 0x 31;  // 31 – это код ‘1’ в 16 -ичной с/с

const char ed='\0x31';     //задание символьной константы ESC-последовательностью в 16 с/с   

const char edd='\61';      //задание символьной константы ESC-последовательностью в 8 с/с      

3. Примеры определений вещественной константы: 

const float f = 1.5f;

const double df = 1.5;

const long double d = -3.7L;

const double expf = 5.55e-12;

 

4. Для уточнения типа константы можно использовать суффикc:

123                                    //тип signed int

11234 L или 11234 l               //тип signed long int

123 U или 123 u,               //тип unsigned int

2. 78 F или 2. 78 f               //тип float

2. 78                                   //тип double

2. 78 L или 2. 78 l               //тип long double

 

5. Следующие объявления констант не эквивалентны:

const int k = 7;

#define k 7

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

 

Знаки операций

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

[ ]                                         // операция индексирования

+ - * / % ++ --              // арифметические операции  

&&     ||      !                         // логические операции И, ИЛИ, НЕ  

=    +=    *= -=   и т.д.   // операции присваивания  

==!= < <= > >=            // операции отношения

       ~ & | ^ << >>              // поразрядные логические операции и операции сдвига  

// (отрицание, И, ИЛИ, исключающее ИЛИ, сдвиг влево, сдвиг вправо)

      ,                                            //операция «запятая», последовательное вычисление

        ::                                              //операция изменения области видимости

Полный список операций мы рассмотрим позже.

 

Знаки пунктуации

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

{ },;: … #

Фигурные скобки{ }

·  обозначают соответственно начало и конец составного оператора или блока:

if (d> x) { d--;   x++; }

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

class point { int x, y;

              point(int, int);

};

· используются при инициализации массивов и структур при их определении:

int a [ 5 ] = { 1, 2, 3, 4, 5 };

 

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

f (a, 7);                          // скобки представляют список аргументов вызова функции

Точка с запятой завершает каждый оператор, каждое определение функции (кроме определения функции) и каждое описание. Отдельный символ; считается пустым оператором.

Двоеточие служит для отделения имени производного класса от списка базовых классов при описании производного класса.

Многоточие (три точки без пробелов) используется для обозначения переменного числа параметров у функции при ее определении и описании.

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

Директивы препроцессора позволяют программисту:

· с помощью директивы #define:
1) создавать именованные константы и
2) описывать макросы – операции, обозначаемые символьными строками, которые уменьшают трудоемкость написания программы и делают текст программы выразительным и удобочитаемым. Во многих случаях использование макросов вместо функций увеличивает скорость исполнения программы за счет исключения потерь времени на вызов функций, правда, за счет увеличения размера загрузочного модуля программы. Общий вид записи директивы:

#define идентификатор замещающий_текст          

#define идентификатор_макроса тело_макроса

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

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

· включать директивой #include в исходный текст программы, поступающий на компиляцию, копию текста из указанного в директиве файла (называемого включаемым или заголовочным) в то место, где находится эта директива. Это повышает мобильность программ: при изменении системы программирования или компьютера приходится менять содержимое только подключаемых файлов. Директива #include имеет следующие форматы:

                              #include <спецификация файла>

                              #include “спецификация файла”

Различие между ними заключается в методе поиска препроцессором включаемого файла. Если имя файла заключено в угловые скобки (< и >), то файл будет отыскиваться в «стандартных» директориях, заданных опцией среды. В поставку компиляторов С++ включается некоторое количество заголовочных файлов, каждый из которых поддерживает отдельное семейство программных средств.

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

Заголовочные файлы в С традиционно имеют расширение.h. Заголовочные файлы языка С++ вообще не имеют расширения. Некоторые заголовочные файлы языка С были преобразованы в заголовочные файлы языка С++: у них убрали расширение h и добавили префикс с (<math.h> à<cmath>; <string.h> à <cstring>).

Современный стиль требует ( для избегания конфликтов идентификаторов ) использования глобального пространства имен std. При этом директива включения заголовочного файла #include трансформируется. Например, директива #include <iostream.h> будет заменена на две инструкции:

#include <iostream>

using namespace std;