РЕКЛАМА

2. Начальные сведения о языке Си.

Язык Си был разработан в 70-е годы как язык системного программирования. При этом ставилась задача получить язык, обеспечивающий реализацию идей процедурного и структурного программирования и возможность реализации специфических приемов системного программирования. Такой язык позволил бы разрабатывать сложные программы на уровне, сравнимом с программированием на Ассемблере, но существенно быстрее. Эти цели, в основном, были достигнуты. Большинство компиляторов для Си написаны на Си, операционная система UNIX <также почти полностью написана на Си. Недостатком Си оказалась низкая надежность разрабатываемых программ из-за отсутствия контроля типов. Попытка поправить дело включением в систему программирования Си отдельной программы, контролирующей неявные преобразования типов, решила эту проблему лишь частично.

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

Рядом фирм, производящих программное обеспечение, разработаны компиляторы для Си и Си++. Системы программирования фирмы Borland International выделяются среди других фирм прежде всего комплексным подходом к разработке программ, выражающимся во включении в систему программирования интегрированной среды разработчика, объединяющей под общим управлением текстовый редактор для ввода исходных текстов программ, компилятор, редактор связей и набор отладочных средств. В 1989 г. этой фирмой была выпущена система Turbo C++, включавшая компилятор Си++, работающий в операционной системе DOS, с 1992 г. выпускаются системы Borland C++, содержащие компиляторы Си++ для DOS и WINDOWS, с 1997 г. поставляется версия Borland C 5.0, содержащая компиляторы Си++ для WINDOWS, причем компилятор для WINDOWS теперь позволяет разрабатывать как 16-разрядные, так и 32-разрядные варианты программ для ПЭВМ с процессорами i486 и Pentium.

Программа на Си/Си++ представляет собой один или несколько исходных файлов, которые могут транслироваться раздельно. Результаты трансляции (объектные файлы) объединяются в исполняемый файл редактором связей (компоновщиком). Обычно различают два типа исходных файлов: файлы заголовков и программные файлы. Файлы заголовков содержат описания типов данных и прототипов функций и предназначены для включения в программные файлы перед их компиляцией, их имена, как правило, имеют расширение .h, например, stdio.h. Программные файлы содержат описания функций и, возможно, глобальных переменных и констант, их имена принято записывать с расширениями .c или .cpp, например, myprog.cpp. Один и тот же файл заголовков может включаться в несколько программных файлов

Каждый файл содержит последовательность так называемых "внешних определений", описывающих типы данных, переменные, константы и функции.

В последующих параграфах этого раздела приведен обзор средств Си/Си++, не связанных с объектной ориентацией Си++.

2.2 Алфавит, базовые типы и описание данных.

Алфавит языка включает практически все символы, имеющиеся на стандартной клавиатуре ПЭВМ:

- латинские буквы A...Z, a...z;

- цифры 0...9;

- знаки операций и разделители:

{ } [ ] ( ) . , -> & * + - ~ ! / % ? : ; = < > | # ^

Некоторые операции обозначаются комбинациями символов, значения символов операций в ряде случаев зависят от контекста, в котором они употреблены.

Базовые (предопределенные) типы данных объединены в две группы: данные целого типа и данные с плавающей точкой (вещественные).

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

Константы целого типа записываются как последовательности десятичных цифр, тип константы зависит от числа цифр в записи константы и может быть уточнен добавлением в конце константы букв L или l (тип long), U или u (тип unsigned) или их сочетания:

321 - константа типа int,

5326u - константа типа unsigned int,

45637778 - константа типа long int,

2746L - константа типа long int.

Целые константы могут записываться в восьмеричной системе счисления, в этом случае первой цифрой должна быть цифра 0, число может содержать только цифры 0 ... 7:

0777 - константа типа int,

0453377 - константа типа long.

Целые константы можно записывать и в шестнадцатеричной системе счисления, в этом случае запись константы начинается с символов 0x или 0X:

0x45F - константа типа int,

0xFFFFFFFF - константа типа unsigned long.

Константы типа char всегда заключаются в одиночные кавычки, значение константы задается либо знаком из используемого набора символов, либо целой константой, которой предшествует обратная косая черта: 'A', '\33', '\042', '\x1B'. Имеется также ряд специальных символов, которые могут указываться в качестве значений константы типа char:

'\n' - новая строка,

'\t' - горизонтальная табуляция,

'\v' - вертикальная табуляция,

'\r' - перевод каретки,

'\f' - перевод страницы,

'\a' - звуковой сигнал,

'\'' - одиночная кавычка (апостроф),

'\"' - двойная кавычка,

'\\' - обратная косая черта.

Вещественные числа могут быть значениями одного из трех типов: float, double, long double. Диапазон значений каждого из этих типов зависит от используемых ЭВМ и компилятора. Константы вещественных типов могут записываться в естественной или экспоненциальной формах и по умолчанию имеют тип double, например, 15.31, 1.43E-3, 2345.1e4. При необходимости тип константы можно уточнить, записав в конце суффикс f или F для типа float, суффикс l или L для типа long double.

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

int  i, j, k; // Три переменных типа int без явной инициализации
double  x=1, y=2; //Две переменных типа double с начальными значениями 1 и 2
char     c1='0' ;   // Переменная типа char, ее значение - код литеры 0

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

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

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

Спецификатор typedef служит для присвоения имени описываемому типу данного и будет рассмотрен подробнее в следующем параграфе.

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

const double Pi  = 3.141592653;

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

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

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

enum идентификатор {список перечисления } деклараторы-инициализаторы;

Здесь идентификатор задает имя перечислимого типа, список перечисления состоит из перечислителей, разделенных запятыми. Каждый перечислитель задается идентификатором и, возможно, целым значением типа char или int, например,

enum color { RED, GREEN, BLUE } en_color;
enum lex_type { CNST, VAR, OPER=3, FUNC };

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

В Си/Си++ для ссылок на переменную того или иного типа служат указатели. Указатель - это тип данного, значением которого является адрес другого данного. При объявлении указателя перед идентификатором записывается знак *. Указатель может инициализироваться адресом данного, для получения адреса служит операция & (амперсенд):

double y;
double  *px, *py = &y;

Для указателей определены операции сравнения, сложения указателя с целым числом, вычитание двух указателей, а также операция индексирования (операция []).

Для обращения к переменной по указателю выполняется операция разыменования, обозначаемая знаком * (звездочка), например, *py = 7.5; .

При объявлении указателя может использоваться описатель const, например,

const int cc = 20;
const int *pc = &cc; // Можно инициализировать адресом константы.
double  *const  delta = 0.001; // Указатель - константа

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

int ii;
int& aii = ii;

При таком описании операторы aii = 5; и ii = 5; эквивалентны.

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

int a [ 5 ] ; // Массив из пяти элементов типа int

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

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

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

int  c [ ] = { 1, 2, 3 }; //  Массив из трех элементов типа int

Массивы с размерностью 2 и более рассматриваются как массивы массивов и для каждого измерения указывается число элементов:

double  aa [ 2 ] [ 2 ] = { 1, 2, 3, 4 }; // Матрица 2 * 2

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

При размещении в памяти в конце строкового литерала добавляется символ '\0', т.е. нулевой байт. Строковый литерал может применяться и для инициализации указателя на тип char:

char   str1 [ 11 ] = "Это строка",
            str2 [ ] = " Размер этого массива определяется"
                        " числом знаков в литерале + 1";
char *pstr = "Указатель с инициализацией строкой";

Имя массива в Си/Си++ является указателем-константой, ссылающимся на первый элемент массива, имеющий индекс, равный нулю. Для обращения к элементу массива указывается идентификатор массива и индекс элемента в круглых скобках, например, c[2], aa[0][1].

2.3 Структуры и объединения

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

struct идентификатор

{ деклараторы членов } деклараторы_инициализаторы;

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

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

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

struct Point_struct    //  Имя структуры
   { int x,  y; }         //   Деклараторы членов структуры
         point1, *ptr_to_point, arpoint [3];    // Данные структурного типа

Члены (компоненты) структуры описываются аналогично данным соответствующего типа и могут быть скалярными данными, указателями, массивами или данными другого структурного типа. Например, для описания структурного типа "прямоугольник со сторонами, параллельными осям координат" можно предложить несколько вариантов:

struct Rect1
   { Point  p1; // Координаты левого верхнего угла
     Point  p2 ; // Координаты правого нижнего угла
   } ;
struct Rect2
   { Point p [ 2 ];
   } ;
struct Rect3 
   { Point  p;  // Левый верхний угол
     int  width;  // Ширина
     int  high;    // Высота прямоугольника
   } ;

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

struct   Value;
struct Tree_element
  { Value  * val;
    Tree_element *left, *right;
  };

Членами структур могут быть так называемые битовые поля, когда в поле памяти переменной целого типа ( int или unsigned int ) размещается несколько целых данных меньшей длины. Пусть, например, в некоторой програме синтаксического разбора описание лексемы содержит тип лексемы (до шести значений) и порядковый номер лексемы в таблице соответствующего типа (до 2000 значениий). Для представления значения типа лексемы достаточно трех двоичных разрядов (трех бит), а для представления чисел от 0 до 2000 - 11 двоичных разрядов (11 бит). Описание структуры, содержащей сведения о лексеме может выглядеть так:

struct Lexema
  { unsigned int type_lex : 3;
    unsigned int num_lex :11;
  }

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

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

Описание объединения строится по той же схеме, что и описание структуры, но вместо ключевого слова struct используется слово union, например, объединение uword позволяет интерпретировать поле памяти либо как unsigned int, либо как массив из двух элементов типа unsigned char.

union uword
  { unsigned int u;
    unsigned char b [ 2 ];
  }

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

typedef  struct { double re, im } COMPLEX;
typedef  int  *PINT;

После таких объявлений синоним имени может использоваться как спецификатор типа:

COMPLEX  ca, *pca;  // переменная типа COMPLEX и указатель на COMPLEX
PINT  pi;  // указатель на int

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

2.4 Операции и выражения

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

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

Результат вычисления выражения зависит от приоритетов операций. В Си++ сложная система приоритетов операций, включающая 16 уровней. В таблице 2.1 приведен перечень операций Си++ с указанием их приоритетов, назначения и схемы записи.

Таблица 2.1

Рассмотрим особенности применения основных из перечисленных выше операций.

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

Для обращения к членам структуры или объединения можно воспользоваться либо именем структурного данного, либо указателем на структурное данное. В первом случае полное имя члена структуры состоит из имени самой структуры и имени члена структуры, разделенных точкой. Во втором случае за именем указателя на структуру ставится знак -> (стрелка), а за ним имя члена структуры. Пусть в программе объявлен структурный тип AnyStruct, содержащий компоненту с именем member типа int и объявлены

AnyStruct s1; // Данное s1 типа AnyStruct

AnyStruct *ps1 = &s1; // Указатель на данное типа AnyStruct

Тогда к члену структуры member из s1 можно обратиться как к s1.member или как ps1->member.

Поскольку членом структуры может быть указатель, в Си++ имеются специальные операции разыменования такого указателя, операции .* и ->. Пусть одним из членов структуры AnyStruct является указатель pp1 на данное типа int. Тогда выражения s1.*pp1 и ps1->*pp1 обеспечат доступ к значению данного, на которое указывает pp1 из s1.

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

int Array1 [ 10 ];

то выражение *Array1=0 служит для присвоения нулевого значения первому элементу массива. Чтобы обратиться к произвольному элементу массива, нужно указать индекс элемента, например, Array1 [ 3 ]. Это выражение эквивалентно выражению *(Array1 + 3), т.е. требуется сначала увеличить указатель Array1 на 3 единицы, а затем разыменовать полученный указатель. При сложении указателя на объект некоторого типа T с целым числом N значение указателя увеличивается на N, умноженное на длину данного типа T. Отметим, что индекс можно задавать не только для имен массивов, но и для любого типа указателя, кроме указателя на тип void :

int *pint = &Array[ 4 ]; pint [ 2 ] =1;
В этом примере указатель pint инициализирован адресом пятого элемента массива Array, а затем седьмому элементу этого массива присвоено значение 1.

В качестве индекса может задаваться любое выражение со значением целого типа.

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

- если один операнд имеет тип long double, другой операнд преобразуется в тип long double;

- иначе, если один операнд имеет тип double, другой операнд преобразуется в тип double;

- иначе, если один операнд имеет тип float, другой операнд преобразуется в тип float;

- иначе, если один операнд имеет тип unsigned long int, другой операнд преобразуется в тип unsigned long int;

- иначе, если один операнд имеет тип long int, >другой операнд преобразуется в тип long int;

- иначе, выполняются стандартные преобразования для целых, при этом типы char, short int и битовые поля типа int преобразуются в тип int, затем, если один операнд имеет больший размер (больший диапазон значений), чем другой операнд, то второй операнд преобразуется к типу операнда большего размера;

- в остальных случаях операнды имеют тип int.

Явное преобразование типов может быть задано в двух формах. Первая форма совместима с Си, в ней за именем типа в круглых скобках записывается преобразуемое значение, которое может быть первичным выражением или выражением с одноместной операцией. Имя типа в этом случае может быть представлено последовательностью описателей, например, (long int * ) pp определеяет преобразование некоторого данного pp в тип указателя на long int. Вторая форма преобразования типа записывается как вызов функции, при этом имя типа должно задаваться идентификатором, например, int (x ). Следует отметить, что результат явного преобразования не является L-значением.

Операции автоувеличения и автоуменьшения ( ++ и -- ) могут быть префиксными и постфиксными и вызывают увеличение (уменьшение) своего операнда на единицу, т.е. выражение ++x эквивалентно x = x +1, а --x эквивалентно x = x - 1. Префиксная операция выполняется до того, как ее операнд будет использован в вычислении выражения, а постфиксная операция выполняется после того, как ее операнд будет использован в выражении, например, в результате вычисления выражения

++x * 2 + y-- *3

переменная x сначала увеличивается на 1, а затем умножается на 2, переменная y сначала умножается на 3, затем уменьшается на 1. Если перед вычислением этого выражения x и y были равны 1, то результат выражения будет равен 5, кроме того переменная x получит значение 2, а переменная y - значение 0. Таким образом, операции автоувеличения и автоуменьшения всегда дают побочный эффект, изменяют значения своих операндов. Операнды этих операций должны быть L-значениями.

Операция ~ (тильда) применяется только к целому значению и заменяет все биты своего операнда со значением 0 на 1, а биты со значением 1 на 0.

Логическое отрицание (операция !) возвращает значение 0 целого типа, если операнд не равен нулю, или значение 1, если операнд равен нулю.

Операции "одноместный +" и "одноместный -" имеют обычный математический смысл, знак + не изменяет значения операнда, знак - меняет знак операнда на противоположный.

Для получения адреса операнда, являющегося L-значением, применяется операция & (амперсанд). Результатом этой операции будет указатель на соответствующий тип данного. Разыменование указателя, т.е. получение значения данного по указателю на него обеспечивается операцией * (звездочка). Результат операции разыменования является L-значением.

В Си++ определены операции размещения данных в динамической памяти и удаления динамических данных из памяти.

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

int *ip = new int; /* создание объекта типа int и получение указателя на него */
int *ip2 = new int(2); // то же с установкой начального значения 2
inr *intArray = new int [ 10 ]; // массив из 10 элементов типа int
double **matr = new double [ m ] [ n ]; // матрица из m строк и n столбцов

Данное, размещенное в динамической памяти операцией new, удаляется из памяти операцией delete с операндом-указателем, значение которого получено операцией new, например,

delete intArray;  delete ip2;

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

Размер данного или типа данного в байтах можно получить по операции sizeof. Операнд может быть любого типа, кроме типа функции и битового поля. Если операндом является имя типа, оно должно заключаться в скобки. Возвращаемое значение имеет предопределенный тип size_t, это целый тип, размер которого определяется реализацией компилятора, обычно типу size_t соответствует unsigned int. Размер массива равен числу байт, занимаемых массивом в памяти, размер строкового литерала - это число знаков в литерале +1, т.е. завершающий нулевой байт учитывается при определении длины литерала. Значение, возвращаемое sizeof является константой.

Двуместные арифметические операции умножения ( * ), деления ( / ), получения остатка от деления нацело ( % ), сложения ( + ) и вычитания ( - ) имеют обычный смысл и обычный относительный приоритет. Если операнды арифметической операции имеют разные типы, предварительно выполняются стандартные арифметические преобразования и тип результата операции определяется общим типом операндов после стандартных преобразований. Следовательно, выражение 7/2 будет иметь значение 3 типа int, так как оба опернда имеют тип int, а выражение 7.0/2 даст результат 3.5 типа double, поскольку этот тип имеет первый операнд.

Операции отношения двух выражений ( <, <=, >, >= ) требуют операндов арифметического типа или же оба операнда должны быть указателями на одинаковый тип. В случае операндов арифметического типа вычисляются значения операндов, выполняются стандартные арифметические преобразования и возвращается 1 типа int, если отношение выполняется (истинно), или 0, если отношение не выполняется (ложно). Когда сравниваются два указателя, результат зависит от относительного размещения в памяти объектов, на которые ссылаются указатели. Операции сравнения ( == и != ) выполняются аналогичным образом, но имеют меньший приоритет.

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

Как уже отмечалось, присваивание, обозначаемое знаком = в Си/Си++ рассматривается как операция и возвращает значение, которое было присвоено левому операнду. Операция присваивания вычисляется справа налево, т.е. сначала вычисляется присваиваемое значение, затем выполняется присваивание. Это позволяет записывать выражения вида x = y = z = 1 для установки одинаковых значений нескольким переменным. Можно, хотя это и снижает наглядность программы, строить и выражения с побочным эффектом вида (x = 2) * (y = 3) + (z = 4 ). Результатом этого выражения будет 24, но одновременно переменные x, y и z получат новые значения.

Кроме простого присваивания имеется набор составных операций присваивания, в которых присваивание совмещается с указанной двуместной операцией. Запись x += y эквивалентна выражению x = x + y.

Для целых операндов определены операции сдвига влево и вправо. При выполнении операции e1 << e2 биты первого операнда сдвигаются влево на e1 разрядов и результат имеет тип первого операнда. Освобождающиеся правые разряды заполняются нулями. При сдвиге вправо ( e1 >> e2 ) если e1 имеет тип unsigned, освобождающиеся левые разряды заполняются нулями, а при e1 типа signed в освобождающихся левых разрядах повторяется знаковый разряд.

Над целыми операндами допустимы операции поразрядного логического умножения, логического сложения и исключающего или (отрицания равнозначности). В этих операциях операнды рассматриваются как последовательности битов и операция выполняется над каждой парой соответствующих разрядов из обоих операндов. Например, результатом выражения ( x >> ( p - n +1)) & ( ~(~0 << n )) будет выделение из целого беззнакового x n битов, начиная с бита с номером p, и сдвиг выделенных битов вправо, т.е. выделение n-разрядного целого, хранящегося в машинном слове x начиная с p-го разряда.

В Си/Си++ имеется конструкция, которая называется условным выражением. Условное выражение строится по схеме:

условие ? выражение1 : выражение2

В качестве условия может выступать любое скалярное выражение. Если результат вычисления условия ненулевой, то значением всего выражения будет выражение1, при нулевом значении условия значение всего выражения определяется выражением2. Второй и третий операнды условного выражения должны быть либо оба арифметического типа, либо однотипными структурами или объединениями, либо указателями одинакового типа, либо один из них - указатель на какой-либо тип, а другой операнд NULL или имеет тип void*. Выражение x > 0 ? 1 : 0 возвращает 1, если x больше 0, и 0 в противном случае.

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

x = 2, e * 3, x +1
будет получено значение 3 и попутно x получит значение 2. Результат умножения e * 3 никак не может быть использован.

2.5 Операторы Си++

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

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

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

x = 3; y = (x +1) * t; i++;

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

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

if (выражение-условие) оператор

if (выражение-условие) оператор-1 else оператор-2

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

В полной форме условного оператора при ненулевом значении выражения-условия выполняется оператор-1 с последующим переходом к следующему оператору программы, а при нулевом значении выражения условия выполняется оператор-2 с переходом к следующему оператору программы.

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

switch ( целое выражение ) оператор
Оператор в этом случае представляет собой тело переключателя, практически всегда является составным и имеет такой вид:

{ case константа-1 : операторы

case константа-2 : операторы

............................

default : операторы

}

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

switch  (count)
  {  case  1 :   x=1;
     case  2 :   x=2;
     case  3 :   x=3;
     default :   x=4;
  }

если значение count равно 1, то после перехода на case 1 будут выполнены все операторы, в результате x станет равным 4. Чтобы разделить ветви переключателя, в конце каждой ветви нужно записать оператор break, не имеющий операндов. По этому оператору происходит выход из переключателя к следующему оператору программы:

switch  (count)
   {  case 1  :   x = 1;  break;
      case 2  :   x = 2;  break;
      case 3  :   x = 3;  break;
      default :   x = 4;
}

Теперь в зависимости от значения count будет выполняться только одна ветвь переключателя и x будет принимать одно из четырех предусмотренных значений.

В Си/Си++ имеется три варианта оператора цикла: цикл с предусловием, цикл с постусловием и цикл с параметром.

Цикл с предусловием строится по схеме

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

Цикл с постусловием строится по схеме:

do оператор while ( выражение-условие )
Выражение-условие вычисляется и проверяется после каждого повторения оператора - тела цикла, цикл повторяется, пока условие выполняется. Тело цикла в цикле с постусловием выполняется хотя бы один раз.

Цикл с параметром строится по схеме:

for ( E1; E2; E3 ) оператор

где E1, E2 и E3 - выражения скалярного типа. Цикл с параметром реализуется по следующему алгоритму:

1. Вычисляется выражение E1. Обычно это выражение выполняет подготовку к началу цикла.

2. Вычисляется выражение E2 и если оно равно нулю выполняется переход к следующему оператору программы ( выход из цикла ). Если E2 не равно нулю, выполняется шаг 3.

3. Выполняется оператор - тело цикла.

4. Вычисляется выражение E3 - выполняется подготовка к повторению цикла, после чего снова выполняется шаг 2.

Пусть требуется подсчитать сумму элементов некоторого массива из n элементов.

С использованием цикла с предусловием это можно сделать так:

int s=0;
int i=0;
while (i < n) s +=a[ i ++];

Эта же задача с применением цикла с постусловием решается следующими операторами:

int s = 0;
int i = 0;
do s +=a[ i++]; while ( i < n );

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

int  i, s;
for ( s = 0, i = 0; i < n; i++) s +=a[ i ];

Объявления переменных можно внести в выражение E1 оператора for и все записать в виде одного оператора for с пустым телом цикла:

for ( int i = 0, s = 0; i < n; s += a [i++] ) ;

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

Несмотря на то, что Си++ содержит полный набор операторов для структурного программирования, в него все же включен оператор перехода:

goto метка ;

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

2.6 Функции

Любая программа на Си/Си++ содержит хотя бы одну функцию. Алгоритм решения любой задачи реализуется путем вызовов функций. Одна из функций считается главной и имеет фиксированное имя, эта функция вызывается операционной системой при запуске программы, а из нее могут вызываться другие функции. При работе в MS DOS главная функция имеет имя main.

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

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

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

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

double sred ( double x, double y, double z)
   { double s;
     s = x + y + z;
     return  s / 3;
   }

Для вызова такой функции при условии, что предварительно объявлены переменные p, a, b, и c, можно записать оператор:

p = sred (a, b, c );

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

Следует отметить ряд дополнительных возможностей описания функций в Си++:

- При описании прототипа функции можно не указывать имена параметров, достаточно указать их типы.

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

double sred ( double x, double y, double z = 0)
   { double s;
      s = x + y + z;
      return  s / 3;
   }

К такой функции можно обращаться с двумя и с тремя аргументами.

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

int  varfunc ( int n, ... );

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

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

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

double sred ( int x, int y, int z = 0)
   { int s;
      s = x + y + z;
      return  s / 3;
   }

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

inline int max ( int x1, int x2)
   { return  x1 > x2 ? x1 : x2 }

В системах программирования Turbo C++ и Borland C++ главная функция (функция main) может принимать три параметра, что позволяет вызывать Си-программы из командной строки DOS с передачей в программу необходимых аргументов. Стандартный прототип функции main имеет вид:

int main ( int argc, char *argv[ ], char *envp[ ] )

В конкретной программе можно объявлять функцию main без возвращаемого значения ( возвращающую тип void ), с использованием только двух первых параметров или вообще без параметров. Параметры argc и argv служат для передачи в программу аргументов в виде массива строк, argc содержит число элементов этого массива, а argv - это массив указателей на элементы массива, причем первый элемент массива, на который указывает argv[0], содержит имя программы (имя exe-файла программы), остальные элементы представляют собой аргументы из командной строки DOS. Параметр envp используется для доступа к элементам текущей среды DOS.

2.7 Библиотека времени выполнения

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

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

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

Ниже приведены имена некоторых файлов заголовков и назначение описанных в них прототипов групп функций.

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

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

CTYPE.H - Функции для проверки и преобразования данных типа char.

FLOAT.H - Макросы для операций над числами с плавающей точкой.

LIMITS.H - Макросы, задающие диапазоны представления целых.

LOCALE.H - Представление даты, времени, денежных единиц.

MATH.H - Пакет стандартных математических функций.

SETJUMP.H - Имена типов и функции для реализации операторов перехода, используется редко.

SIGNAL.H - Макросы для сигнализации об ошибках согласно стандарта ANSI.

STDARG.H - Макросы для вызова функций с переменным числом аргументов.

STDDEF.H - Определение общих типов для указателей, типов size_t и NULL.

STDIO.H - Стандартные функции ввода-вывода.

STDLIB.H - Определение общих типов, переменных и функций.

STRING.H - Функции для операций над строковыми данными.

TIME.H - Структуры и функции для операций с датами и временем.

В Си++ добавлены операции с комплексными числами и десятичными данными:

BCD.H - Данные, представленные в десятичной системе счисления

COMPLEX.H - Функции и операции над комплексными числами.

Имеются также файлы прототипов функций для распределения и освобождения динамической памяти, использования средств DOS и BIOS.

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

# include   < имя файла >

Например, для включения заголовка с функциями ввод-вывода в стиле Си в начале программы записывается строка