vector, очень похожий на тот, который был определен выше, а
implement(vector,int) расширялся в определение функций этого
класса. Поскольку implement(vector,int) в результате расширения
превращается в определение функций, его можно использовать в
программе только один раз, в то время как declare(vector,int)
должно использоваться по одному разу в каждом файле, работающем с
этим типом целых векторов.
- стр 44 -
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? Обычно точный тип должен впоследствие быть
восстановлен, чтобы обеспечить правильное использование объекта.
Для этого нужно или в какой-то форме хранить информацию о типе в
самом объекте, или обеспечить, чтобы во вмещающий класс помещались
- стр 45 -
только объекты данного типа. Последнее легко достигается с помощью
производного класса. Вы можете, например, создать вектор
указателей на apple:
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; }
virual void draw();
virtual void rotate(int);
//...
};
Функции, которые можно определить не зная точно определенной фигуры
(например, move и where, то есть, "передвинуть" и "где"), можно
описать как обычно. Остальные функции описываются как virual, то
есть такие, которые должны определяться в производном классе.
Например:
- стр 46 -
class circle: public shape {
int radius;
public:
void draw();
void rotatte(int i) {}
//...
};
Теперь, если shape_vec - вектор фигур, то можно написать:
for (int i = 0; i
* Глава 2 *
Описания и Константы
Совершенство достигается только к моменту краха.
- С.Н. Паркинсон
В этой главе описаны основные типы (char, int, float и т.д.) и
основные способы построения из них новых типов (функций, векторов,
указателей и т.д.). Имя вводится в программе посредством описаниия,
которое задает его тип и, возможно, начальное значение. Даны
понятия описания, определения, области видимости имен, времени
жизни объектов и типов. Описываются способы записи констант в C++,
а также способы определения символических констант. Примеры просто
демонстрируют характерные черты языка. Более развернутый и
реалистичный пример приводится в следующей главе для знакомства с
выраженями и операторами языка C++. Механизмы задания типов,
определяемых пользователем, с присоединенными операциями
представлены в Главах 4, 5 и 6 и здесь не упоминаются.
2.1 Описания
Прежде чем имя (идентификатор) может быть использовано в C++
программе, он должно быть описано. Это значит, что надо задать его
тип, чтобы сообщить компилятору, к какого вида объектам относится
имя. Вот несколько примеров, иллюстрирующих разнообразие описаний:
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;
- стр 48 -
не являются одновременно определениями. Это означает, что объект, к
которому они относятся, должен быть определен где-то еще. Код
(тело) функции sqrt должен задаваться неким другим описанием,
память для переменной error_number типа int должна выделяться неким
другим описанием, и какое-то другое описание типа user должно
определять, что он из себя представляет. В C++ программе всегда
должно быть только одно определение каждого имени, но описаний
может быть много, и все описания должны согласовываться с типом
объекта, к которому они относятся, поэтому в этом фрагменте есть
две ошибки:
int count;
int count; // ошибка: переопределение
exnern int error_number;
exnern int error_number; // ошибка: несоответствие типов
а в этом - ниодной (об использовании extern см. #4.2):
exnern int error_number;
exnern 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 Область Видимости
Описание вводит имя в области видимости; то есть, имя может
использоваться только в определенной части программы. Для имени,
описанного в функции (такое имя часто называют локальным), эта
область видимости простирается от точки описания до конца блока, в
котором появилось описание; для имени не в функции и не в классе
(называемого часто глобальным именем) область видимости
простирается от точки описания до конца файла, в котором появилось
описание. Описание имени в блоке может скрывать (прятать) описание
во внутреннем блоке или глобальное имя. Это значит, что можно
- стр 49 -
переопределять имя внутри блока для ссылки на другой объект. После
выхода из блока имя вновь обретает свое прежнее значение. Например:
int x; // глобальное x
f() {
int x; // локальное x прячет глобальное x
x = 1; // присвоить локальному x
{
int x; // прячет первое локальное x
x = 2; // присвоить второму локальному x
}
x = 3; // присвоить первому локальному x
}
int* p = &x; // взять адрес глобального x
Скрытие имен неизбежно при написании больших программ. Однако
читающий человек легко может не заметить, что имя скрыто, и
некоторые ошибки, возникающие вследствие этого, очень трудно
обнаружить, главным образом потому, что они редкие. Значит скрытие
имен следует минимизировать. Использование для глобальных
переменных имен вроде i или x напрашивается на неприятности.
С помощью применения операции разрешения области видимости ::
можно использовать скрытое глобальное имя. Например:
int x;
f()
{
int x = 1; // скрывает глобальное x
::x = 2; // присваивает глобальному x
}
Но возможности использовать скрытое локальное имя нет.
Область видимости имени начинается в точке описания. Это
означает, что имя можно использовать даже для задания его
собственного значения. Например:
int x;
f()
{
int x = x; // извращение
}
Это не является недопустимым, хотя и бессмысленно, и компилятор
предупредит, что x "used before set" ("использовано до того, как
задано"), если вы попробуете так сделать. Можно, напротив, не
применяя операцию ::, использовать одно имя для ссылки на два
различных объекта в блоке. Например:
- стр 50 -
int x;
f() // извращение
{
int y = x; // глобальное x
int x = 22;
y = x; // локальное x
}
Переменная y инициализируется значением глобального x, 11, а
затем ему присваивается значение локальной переменной x, 22.