Компьютерные науки - Учебники на русском языке - Скачать бесплатно

#include

void error(char* p)
(*
cerr << p << "\n";
// cerr - выходной поток сообщений об ошибках
exit(1);
*)

void vector::set_size(int) (* /* пустышка */ *)

int& vec::operator[](int i)
(*
if (i
// индекс vec за границами
return elem(i);
*)




- 30 -


main()
(*
vector a(10);
for (int i=0; i
a[i] = i;
cout << a[i] << " ";
*)
cout << "\n";
vec b(10,19);
for (i=0; i
for (i=0; i<< b[i+10] << " ";
cout << "\n";
*)

Он выдает
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9

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

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

1.14 Еще об операциях

Другое направление развития - снабдить вектора операция-
ми:

class Vec : public vector (*
public:
Vec(int s) : (s) (**)
Vec(Vec&);
~Vec() (**)
void operator=(Vec&);
void operator*=(Vec&);
void operator*=(int);
//...
*);

Обратите внимание на способ определения конструктора
производного класса, Vec::Vec(), когда он передает свой пара-
метр конструктору базового класса vector::vector() и больше
не делает ничего. Это полезная парадигма. Операция присваива-
ния перегружена, ее можно определить так:

void Vec::operator=(Vec& a)
(*
int s = size();
if (s!=a.size()) error("bad vector size for =");
// плохой размер вектора для =
for (int i = 0; i
*)

Присваивание объектов класса Vec теперь действительно
копирует элементы, в то время как присваивание объектов


- 31 -
vector просто копирует структуру, управляющую доступом к эле-
ментам. Последнее, однако, происходит и тогда, когда vector
копируется без явного использования операции присваивания:
(1) когда vector передается как параметр и (3) когда vector
передается как значение, возвращаемое функцией. Чтобы обраба-
тывать эти случаи для векторов Vec, вы определяете конструк-
тор Vec(Vec&):
Vec::Vec(Vec& a) : (a.size())
(*
int sz = a.size();
for (int i = 0; i
*)
Этот конструктор инициализирует Vec как копию другого
Vec, и будет вызываться в отмеченных выше случаях.
Выражение в левой части таких операций, как = и +=, бе-
зусловно определено, поэтому кажется вполне естественным реа-
лизовать их как операции над объектом, который обозначается
(денотируется) этим выражением. В частности, тогда они смогут
изменять значение своего первого операнда. Левый операнд та-
ких операций, как + и - не требует особого внимания. Вы могли
бы, например, передавать оба аргумента по значению и все рав-
но получить правильную реализацию векторного сложения. Однако
вектора могут оказаться большими, поэтому чтобы избежать не-
нужного копирования операнды операции + передаются в operator
+() по ссылке:

Vec operator+(Vec& a,Vec &b)
(*
int s = a.size();
if (s != b.size()) error("bad vector size for +");
// плохой размер вектора для +
Vec sum(s);
for (int i=0; i
sum.elem(i) = a.elem(i) + b.elem(i);
return sum;
*)

Вот пример небольшой программы, которую можно выполнить,
если скомпилировать ее вместе с ранее приведенными описаниями
vector:

#include

void error(char* p) (*
cerr << p << "\n";
exit(1);
*)

void vector::set_size(int) (* /*...*/ *)

int& vec::operator[](int i) (* /*...*/ *)

main()
(*
Vec a(10);
Vec b(10);
for (int i=0; i
b = a;
Vec c = a+b;
for (i=0; i<< c[i] << "\n";
*)

1.15 Друзья (friend)

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


- 32 -
дать функциям не членам возможность доступа к закрытой части
класса. Например, если бы не было функции "доступа без про-
верки" vector::elem(), вам пришлось бы проверять индекс i на
соответствие границам три раза за каждый проход цикла. Здесь
мы избежали этой сложности, но она довольно типична, поэтому
у класса есть механизм предоставления права доступа к своей
закрытой части функциям не членам. Просто в класс помещается
описание функции, перед которым стоит ключевое слово friend.
Например, если имеется

class Vec; // Vec - имя класса
class vector (*
friend Vec operator+(Vec, Vec);
//...
*);

То вы можете написать
Vec operator+(Vec a, Vec b)
(*
int s = a.size();
if (s != b.size()) error("bad vector size for +");
// плохой размер вектора для +
Vec& sum = *new Vec(s);
int* sp = sum.v;
int* ap = a.v;
int* bp = b.v;
while (s--) *sp++ = *ap++ + *bp++;
return sum;
*)

Одним из особенно полезных аспектов механизма friend яв-
ляется то, что функция может быть другом двух и более клас-
сов. Чтобы увидеть это, рассмотрим определение vector и
matrix, а затем определение функции умножения (см. #с.8.8).

1.16 Обобщенные Вектора

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

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

#include

declare(vector,int);

main()
(*
vector(int) vv(10);
vv[2] = 3;
vv[10] = 4; // ошибка: выход за границы
*)

Файл vector.h таким образом определяет макросы, чтобы
макрос declare(vector,int) после расширения превращался в
описание класса vector, очень похожий на тот, который был оп-
ределен выше, а макрос implement(vector,int) расширялся в оп-
ределение функций этого класса. Поскольку макрос
implement(vector,int) в результате расширения превращается в


- 33 -
определение функций, его можно использовать в программе толь-
ко один раз, в то время как declare(vector,int) должно ис-
пользоваться по одному разу в каждом файле, работающем с этим
типом целых векторов.

declare(vector,char);
//...
implement(vector,char);

даст вам отдельный тип "вектор символов". Пример реализации
обобщенных классов с помощью макросов приведен в #7.3.5.
1.17 Полиморфные Вектора

У вас есть другая возможность - определить ваш векторный
и другие вмещающие классы через указатели на объекты некото-
рого класса:
class common (*
//...
*);
class vector (*
common** v;
//...
public:
cvector(int);
common*& elem(int);
common*& operator[](int);
//...
*);

Заметьте, что поскольку в таких векторах хранятся указа-
тели, а не сами объекты, объект может быть "в" нескольких та-
ких векторах одновременно. Это очень полезное свойство
подобных вмещающих классов, таких, как вектора, связанные
списки, множества и т.д. Кроме того, можно присваивать указа-
тель на производный класс указателю на его базовый класс, по-
этому можно использовать приведенный выше cvector для хране-
ния указателей на объекты всех производных от common классов.
Например:

class apple : public common (* /*...*/ *)
class orange : public common (* /*...*/ *)
class apple_vector : public cvector (*
public:

cvector fruitbowl(100);
//...
apple aa;
orange oo;
//...
fruitbowl[0] = &aa;
fruitbowl[1] = &oo;
*)

Однако, точный тип объекта, вошедшего в такой вмещающий
класс, больше компилятору не известен. Например, в предыдущем
примере вы знаете, что элемент вектора является common, но
является он apple или orange? Обычно точный тип должен впос-
ледствии быть восстановлен, чтобы обеспечить правильное ис-
пользование объекта. Для этого нужно или в какой-то форме
хранить информацию о типе в самом объекте, или обеспечить,
чтобы во вмещающий класс помещались только объекты данного
типа. Последнее легко достигается с помощью производного
класса. Вы можете, например, создать вектор указателей на
apple:





- 34 -


class apple_vector : public cvector (*
public:
apple*& elem(int i)
(* return (apple*&) cvector::elem(i); *)
//...
*);

используя запись приведения к типу (тип)выражение, чтобы
преобразовать common*& (ссылку на указатель на common), кото-
рую возвращает cvector::elem, в apple*&. Такое применение
производных классов создает альтернативу обобщенным классам.
Писать его немного труднее (если не использовать макросы та-
ким образом, чтобы производные классы фактически реализовыва-
ли обобщенные классы, см. #7.3.5), но оно имеет то преиму-
щество, что все производные классы совместно используют
единственную копию функции базового класса. В случае обобщен-
ных классов, таких, как vector(type), для каждого нового ис-
пользуемого типа должна создаваться (с помощью implement())
новая копия таких функций. Другой способ, хранение идентифи-
кации типа в каждом объекте, приводит нас к стилю программи-
рования, который часто называют объекто-основанным или объек-
тно-ориентированным.

1.18 Виртуальные Функции

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

class shape (*
point center;
color col;
//...
public:
void move(point to) (* center=to; draw(); *)
point where() (* return center; *)
virtual void draw();
virtual void rotate(int);
//...
*);

Функции, которые можно определить не зная точно определен-
ной фигуры (например, move и where, то есть, "передвинуть" и
"где"), можно описать как обычно. Остальные функции описыва-
ются как virtual, то есть такие, которые должны определяться
в производном классе. Например:

class circle: public shape (*
int radius;
public:
void draw();
void rotatte(int i) (**)
//...
*);

Теперь, если shape_vec - вектор фигур, то можно написать:

for (int i = 0; i
shape_vec[i].rotate(45);

чтобы повернуть все фигуры на 45 градусов (и заново на-
рисовать)

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


- 35 -
программным обеспечением. Ведь по сути дела, типичное дейс-
твие пользователя - это ткнуть в какой-нибудь объект и ска-
зать Кто ты? Что ты такое? и Делай, что надо! не давая ника-
кой информации о типе. Программа может и должна уяснить это
для себя сама.

- 36 -

Глава 2

Описания и Константы

Совершенство достигается только к моменту краха.
- С.Н. Паркинсон

В этой главе описаны основные типы (char, int, float и
т.д.) и основные способы построения из них новых типов (функ-
ций, векторов, указателей и т.д.). Имя вводится в программе
посредством описания, которое задает его тип и, возможно, на-
чальное значение. Даны понятия описания, определения, области
видимости имен, времени жизни объектов и типов. Описываются
способы записи констант в С++, а также способы определения
символических констант. Примеры просто демонстрируют харак-
терные черты языка. Более развернутый и реалистичный пример
приводится в следующей главе для знакомства с выражениями и
операторами языка С++. Механизмы задания типов, определяемых
пользователем, с присоединенными операциями представлены в
Главах 4, 5 и 6 и здесь не упоминаются.

2.1 Описания

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

char ch;
int count = 1;
char* name = "Bjarne";
struct complex (* float re, im; *);
complex cvar;
extern complex sqrt(complex);
extern int error_number;
typedef complex point;
float real(complex* p) (* return p->re; *);
const double pi = 3.1415926535897932385;
struct user;

Как можно видеть из этих примеров, описание может делать
больше чем просто ассоциировать тип с именем. Большинство
описаний являются также определениями то есть они также опре-
деляют для имени сущность, к которой оно относится. Для ch,
count и cvar этой сущностью является соответствующий объем
памяти, который должен использоваться как переменная - эта
память будет выделена. Для real это заданная функция. Для
constant pi это значение 3.1415926535897932385. Для complex
этой сущностью является новый тип. Для point это тип complex,
поэтому point становится синонимом complex. Только описания

extern complex sqrt(complex);
extern int error_number;
struct user;

не являются одновременно определениями. Это означает,
что объект, к которому они относятся, должен быть определен
где-то еще. Код (тело) функции sqrt должен задаваться неким
другим описанием, память для переменной error_number типа int
должна выделяться неким другим описанием, и какое-то другое
описание типа user должно определять, что он из себя предс-
тавляет. В С++ программе всегда должно быть только одно опре-
деление каждого имени, но описаний может быть много, и все
описания должны согласовываться с типом объекта, к которому
они относятся, поэтому в этом фрагменте есть две ошибки:



- 37 -
int count;
int count; // ошибка: переопределение
extern int error_number;
extern int error_number; // ошибка: несоответствие типов

а в этом - ни одной (об использовании extern см. #4.2):

extern int error_number;
extern int error_number;

Некоторые описания задают "значение" для сущностей, ко-
торые они определяют:

struct complex (* float re, im; *);
typedef complex point;
float real(complex* p) (* return p->re *);
const double pi = 3.1415926535897932385;

Для типов, функций и констант "значение" неизменно. Для
неконстантных типов данных начальное значение может впоследс-
твии изменяться:

int count = 1;
char* name = "Bjarne";
//...
count = 2;
name = "Marian";

Из всех определений только

char ch;

не задает значение. Всякое описание, задающее значение,
является определением.

2.1.1 Область Видимости

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

int x; // глобальное x

f() (*
int x; // локальное x прячет глобальное x
x = 1; // присвоить локальному x
(*
int x; // прячет первое локальное x
x = 2; // присвоить второму локальному x
*)
x = 3; // присвоить первому локальному x
*)

int* p = &x; // взять адрес глобального x

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


- 38 -
очень трудно обнаружить, главным образом потому, что они ред-
кие. Значит сокрытие имен следует минимизировать. Использова-
ние для глобальных переменных имен вроде i или x напрашивает-
ся на неприятности.

С помощью применения операции разрешения области
видимости :: можно использовать скрытое глобальное имя. Нап-
ример:

int x;

f()
(*
int x = 1; // скрывает глобальное x
::x = 2; // присваивает глобальному x
*)

Но возможности использовать скрытое локальное имя нет.

Область видимости имени начинается в точке описания. Это
означает, что имя можно использовать даже для задания его
собственного значения. Например:

int x;

f()
(*
int x = x; // извращение
*)

Это не является недопустимым, хотя и бессмысленно, и
компилятор предупредит, что x "used before set" ("использова-
но до того, как задано"), если вы попробуете так сделать.
Можно, напротив, не применяя операцию ::, использовать одно
имя для ссылки на два различных объекта в блоке. Например:

int x;

f() // извращение
(*
int y = x; // глобальное x
int x = 22;
y = x; // локальное x
*)

Переменная y инициализируется значением глобального x,
11, а затем ему присваивается значение локальной переменной
x, 22.

Имена параметров функции считаются описанными в самом
внешнем блоке функции, поэтому

f(int x)
(*
int x; // ошибка
*)

содержит ошибку, так как x определено дважды в одной и
той же области видимости.

2.1.2 Объекты и Адреса (Lvalue)

Можно назначать и использовать переменные, не имеющие
имен, и можно осуществлять присваивание выражениям странного
вида (например, *p[a+10]=7). Следовательно, есть потребность
в имени "нечто в памяти". Вот соответствующая цитата из спра-
вочного руководства по С++: "Объект есть область памяти.


- 39 -
lvalue есть выражение, ссылающееся на объект" (#с.5). Слово
"lvalue" первоначально было придумано для значения "нечто,
что может стоять в левой части присваивания". Однако не вся-
кое lvalue можно использовать в левой части присваивания; бы-
вают lvalue, ссылающиеся на константу (см. #2.4).

2.1.3 Время Жизни

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

--------------------
* Команда #include была выброшена из примеров
в этой главе для экономии места. Она необходима в примерах,
производящих вывод, чтобы они были полными. (прим. автора)

int a = 1;

void f()
(*
int b = 1; // инициализируется при каждом
// вызове f()
static int c = 1; // инициализируется только один раз
cout << " a = " << a++
<< " b = " << b++
<< " c = " << c++ << "\n";
*)

main()
(*
while (a < 4) f();
*)

производит вывод

a = 1 b = 1 c = 1
a = 2 b = 1 c = 2
a = 3 b = 1 c = 3

Не инициализированная явно статическая (static) перемен-
ная неявно инициализируется нулем.

С помощью операций new и delete программист может также
создавать объекты, время жизни которых управляется непосредс-
твенно, см. #3.2.4.

2.2 Имена

Имя (идентификатор) состоит из последовательности букв и
цифр. Первый символ должен быть буквой. Символ подчерка _
считается буквой. С++ не налагает ограничений на число симво-
лов в имени, но некоторые части реализации находятся вне ве-
дения автора компилятора (в частности, загрузчик), и они, к
сожалению, такие ограничения налагают. Некоторые среды выпол-
нения также делают необходимым расширить или ограничить набор
символов, допустимых в идентификаторе. Расширения (например,
при допущении в именах символа $) порождают непереносимые
программы. В качестве имени не могут использоваться ключевые
слова С++ (см. #с.2.3). Примеры имен:

hello this_is_a_most_unusially_long_name
DEFINED foO bAr u_name HorseSense
var0 var1 CLASS _class ___


- 40 -

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

012 a fool $sys class 3var
pay.due foo~bar .name if

Буквы в верхнем и нижнем регистрах считаются различными,
поэтому Count и count - различные имена, но вводить имена,
лишь незначительно отличающиеся друг от друга, нежелательно.
Имена, начинающиеся с подчерка, по традиции используются для
специальных средств среды выполнения, поэтому использовать
такие имена в прикладных программах нежелательно.

Во время чтения программы компилятор всегда ищет наибо-
лее длинную строку, составляющую имя, поэтому var10 - это од-
но имя, а не имя var, за которым следует число 10, и elseif -
одно имя, а не ключевое слово else, после которого стоит клю-
чевое слово if.

2.3 Типы

Каждое имя (идентификатор) в С++ программе имеет ассоци-
ированный с ним тип. Этот тип определяет, какие операции мож-
но применять к имени (то есть к объекту, на который оно
ссылается), и как эти операции интерпретируются. Например:

int error number;
float real(complex* p);

Поскольку error_number описано как int, его можно прис-
ваивать, использовать в арифметических выражениях и т.д. Тог-
да как функция real может вызываться с адресом complex в ка-
честве параметра. Можно взять адрес любого из них. Некоторые
имена, вроде int и complex, являются именами типов. Обычно
имя типа используется в описании для спецификации другого
имени. Единственные отличные от этого действия над именем ти-
па - это sizeof (для определения количества памяти, которая
требуется для хранения объекта типа) и new (для размещения
объекта типа в свободной памяти). Например:

main()
(*
int* p = new int;
cout << "sizeof(int) = " << sizeof(int) "\n";
*)

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

float f;
char* p;
//...
long ll = long(p); // преобразует p в long
int i = int(f); // преобразует f в int

2.3.1 Основные Типы

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

char
short int
int
long int



- 41 -
для представления целых различных размеров,

float
double

для представления чисел с плавающей точкой,

unsigned char
unsigned short int
unsigned int
unsigned long int

для представления беззнаковых целых, логических значе-
ний, битовых массивов и т.п. Для большей компактности записи
можно опускать int в комбинациях из нескольких слов, что не
меняет смысла. Так, long означает long int, и unsigned тип
означает тип unsigned int. В общем, когда в описании опущен
тип, он предполагается int. Например:

const a = 1;
static x;

все определяют объект типа int.

Целый тип char наиболее удобен для хранения и обработки
символов на данном компьютере, обычно это 8-битовый байт.
Размеры объектов С++ выражаются в единицах размера char, поэ-
тому по определению sizeof(char)==1. В зависимости от аппа-
ратного обеспечения char является знаковым или беззнаковым
целым. Тип unsigned char, конечно, всегда беззнаковый, и при
его использовании получаются более переносимые программы, но
из-за применения его вместо просто char могут возникать зна-
чительные потери в эффективности.

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

1==sizeof(char)<=sizeof(short)<= sizeof(int)<=sizeof(long)
sizeof(float)<=sizeof(double)

Однако обычно разумно предполагать, что в char могут
храниться целые числа в диапазоне 0..127 (в нем всегда могут
храниться символы машинного набора символов), что short и int
имеют не менее 16 бит, что int имеет размер, соответствующий
целой арифметике, и что long имеет по меньшей мере 24 бита.
Предполагать что-либо помимо этого рискованно, и даже эти эм-
пирические правила применимы не везде. Таблицу характеристик
аппаратного обеспечения для некоторых машин можно найти в #с.
2.6.

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


- 42 -

unsigned surprise = -1;

допустимо (но компилятор обязательно сделает предупреждение).

2.3.2 Неявное Преобразование Типа

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

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

int i1 = 256+255;
char ch = i1 // ch == 255
int i2 = ch; // i2 == ?

В присваивании ch=i1 теряется один бит (самый значи-
мый!), и ch будет содержать двоичный код "все-единицы" (т.е.
8 единиц); при присваивании i2 это никак не может превратить-
ся в 511! Но каким же может быть значение i2? На DEC VAX, где
char знаковое, ответ будет -1, на AT&T 3B-20, где char безз-
наковые, ответ будет 255. В С++ нет динамического (т.е. дейс-
твующего во время исполнения) механизма для разрешения такого
рода проблем, а выяснение на стадии компиляции вообще очень
сложно, поэтому программист должен быть внимателен.

2.3.3 Производные Типы

Другие типы можно выводить из основных типов (и типов,
определенных пользователем) посредством операций описания:

* указатель
& ссылка
[] вектор
() функция

и механизма определения структур. Например:

int* a;
float v[10];
char* p[20]; // вектор из 20 указателей на символ
void f(int);
struct str (* short length; char* p; *);

Правила построения типов с помощью этих операций подроб-
но объясняются в #с.8.3-4. Основная идея состоит в том, что
описание производного типа отражает его использование. Напри-
мер:

int v[10]; // описывает вектор
i = v[3]; // использует элемент вектора

int* p; // описывает указатель
i = *p; // использует указываемый объект

Вся сложность понимания записи производных типов проис-
текает из того, что операции * и & префиксные, а операции []
() постфиксные, поэтому для формулировки типов в тех случаях,
когда приоритеты операций создают затруднения, надо использо-


- 43 -
вать скобки. Например, поскольку приоритет у [] выше, чем у
*, то

int* v[10]; // вектор указателей
int (*p)[10]; // указатель на вектор

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

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

int x, y; // int x; int y;

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

int* p, y; // int* p; int y; НЕ int* y;
int x, *p; // int x; int* p;
int v[10], *p; // int v[10]; int* p;

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

2.3.4 Тип void

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

void f() // f не возвращает значение
void* pv; // указатель на объект неизвестного типа

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

void* allocate(int size); // выделить
void deallocate(void*); // освободить

f() (*
int* pi = (int*)allocate(10*sizeof(int));
char* pc = (char*)allocate(10);
//...
deallocate(pi);
deallocate(pc);
*)

2.3.5 Указатели

Для большинства типов T T* является типом арифметический
указатель на T. То есть, в переменной типа T* может храниться


- 44 -
адрес объекта типа T. Для указателей на вектора и указателей
на функции вам, к сожалению, придется пользоваться более
сложной записью:

int* pi;
char** cpp; // указатель на указатель на char
int (*vp)[10]; // указатель на вектор из 10 int'ов
int (*fp)(char, char*); // указатель на функцию
//получающую параметры(char, char*)
// и возвращающую int

Основная операция над указателем - разыменование, то
есть ссылка на объект, на который указывает указатель. Эта
операция также называется косвенным обращением. Операция ра-
зыменования - это унарное * (префиксное). Например:

char c1 = 'a';
char* p = &c1; // в p хранится адрес c1
char c2 = *p; // c2 = 'a'

Переменная, на которую указывает p,- это c1, а значение,
которое хранится в c1, это 'a', поэтому присваиваемое c2 зна-
чение *p есть 'a'.

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

int strlen(char* p)
(*
int i = 0;
while (*p++) i++;
return i;
*)

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

int strlen(char* p)
(*
char* q = p;
while (*q++) ;
return q-p-1;
*)

Очень полезными могут оказаться указатели на функции.
Они обсуждаются в #4.6.7.

2.3.6 Вектора

Для типа T T[size] является типом "вектор из size эле-
ментов типа T". Элементы индексируются (нумеруются) от 0 до
size-1. Например:

float v[3]; // вектор из трех float: v[0], v[1], v[2]
int a[2][5]; // два вектора из пяти int
char* vpc; // вектор из 32 указателей на символ

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