Жанр: Учеба
Язык С++ с комментариями
...ambuf на самом деле определен в
, где также находится и настоящее определение ostream.
Пожалуйста, не испытывайте примеры, определяющие ostream в этом и
последующих разделах; пока вы не сможете полностью избежать
использования , компилятор будет возражать против
переопределений.
Определение типа, определяемого пользователем (который в C++
называется class, т.е. класс), специфицирует данные, необходимые
для представления объекта этого типа, и множество операций для
работы с этими объектами. Определение имеет две части: закрытую
(private) часть, содержащую информацию, которой может пользоваться
только его разработчик, и открытую (public) часть, представляющую
интерфейс типа с пользователем:
class ostream {
streambuf* buf;
int state;
public:
void put(char*);
void put(long);
void put(double);
}
Описания после метки public задают интерфейс: пользователь может
обращаться только к трем функциям put(). Описания перед меткой
public задают представление объекта класса ostream; имена buf и
state могут использоваться только функциями put(), описанными в
открытой части.
class определяет тип, а не объект данных, поэтому чтобы
использовать ostream, мы должны один такой объект описать (так же,
как мы описываем переменные типа int):
ostream my_out;
- стр 33 -
Считая, что my_out был соответствующим образом проинициализирован
(как, объясняется в #1.10), его можно использовать например так:
my_out.put("Hello, world\n");
С помощью операции точка выбирается член класса для данного
объекта этого класса. Здесь для объекта my_out вызывается член
функция put().
Функция может определяться так:
void ostream::put(char* p)
{
while (*p) buf.sputc(*p++);
}
где sputc() - функция, которая помещает символ в streambuf.
Префикс ostream необходим, чтобы отличить put() ostream'а от других
функций с именем put().
Для обращения к функции члену должен быть указан объект класса. В
функции члене можно ссылаться на этот объект неявно, как это
делалось выше в ostream::put(): в каждом вызове buf относится к
члену buf объекта, для которого функция вызвана.
Можно также ссылаться на этот объект явно посредством указателя с
именем this. В функции члене класса X this неявно описан как X*
(указатель на X) и инициализирован указателем на тот объект, для
которого эта функция вызвана. Определение ostream::put() можно
также записать в виде:
void ostream::put(char* p)
{
while (*p) this-"buf.sputc(*p++);
}
Операция -" применяется для выбора члена объекта, заданного
указателем.
1.8 Перегрузка операций
Настоящий класс ostream определяет операцию "", чтобы сделать
удобным вывод нескольких объектов одним оператором. Давайте
посмотрим, как это сделано.
Чтобы определить @, где @ - некоторая операция языка C++, для
каждого определяемого пользователем типа вы определяете функцию с
именем operator@, которая получает параметры соответствующего типа.
Например:
- стр 34 -
class ostream {
//...
ostream operator""(char*);
};
ostream ostream::operator""(char* p)
{
while (*p) buf.sputc(*p++);
return *this;
}
определяет операцию "" как член класса ostream, поэтому s"
");
а если применить операцию взятия адреса, то вы получите адрес
объекта, на который ссылается ссылка:
&s1 == &my_out
Первая очевидная польза от ссылок состоит в том, чтобы обеспечить
передачу адреса объекта, а не самого объекта, в фукнкцию вывода (в
некоторых языках это называется передачей параметра по ссылке):
ostream& operator""(ostream& s, complex z) {
return s "" "(" "" z.real "" "," "" z.imag "" ")";
}
Достаточно интересно, что тело функции осталось без изменений, но
если вы будете осуществлять присваивание s, то будете
воздействовать на сам объект, а не на его копию. В данном случае
то, что возвращается ссылка, также повышает эффективность,
поскольку очевидный способ реализации ссылки - это указатель, а
передача указателя гораздо дешевле, чем передача большой структуры
данных.
Ссылки также существенны для определения потока ввода, поскольку
операция ввода получает в качестве операнда переменную для
считывания. Если бы ссылки не использовались, то пользователь
должен был бы явно передавать указатели в функции ввода.
class istream {
//...
int state;
public:
istream& operator""(char&);
istream& operator""(char*);
istream& operator""(int&);
istream& operator""(long&);
//...
};
Заметьте, что для чтения long и int используются разные функции,
тогда как для их печати требовалась только одна. Это вполне обычно,
и причина в том, что int может быть преобразовано в long по
стандартным правилам неявного преобразования (#с.6.6), избавляя
таким образом программиста от беспокойства по поводу написания
обеих функций ввода.
- стр 36 -
1.10 Конструкторы
Определение ostream как класса сделало члены данные закрытыми.
Только функция член имеет доступ к закрытым членам, поэтому надо
предусмотреть функцию для инициализации. Такая функция называется
конструктором и отличается тем, что имеет то же имя, что и ее
класс:
class ostream {
//...
ostream(streambuf*);
ostream(int size, char* s);
};
Здесь задано два конструктора. Один получает вышеупомянутый
streambuf для реального вывода, другой получает размер и указатель
на символ для форматирования строки. В описании необходимый для
конструктора список параметров присоединяется к имени. Теперь вы
можете, например, описать такие потоки:
ostream my_out(&some_stream_buffer);
char xx[256];
ostream xx_stream(256,xx);
Описание my_out не только задает соответствующий объем памяти
где-то в другом месте, оно также вызывает конструктор
ostream::ostream(streambuf*), чтобы инициализировать его параметром
&some_stream_buffer, предположительно указателем на подходящий
объект класса streambuf. Описание конструкторов для класса не
только дает способ инициализации объектов, но также обеспечивает
то, что все объекты этого класса будут проинициализированы. Если
для класса были описаны конструкторы, то невозможно описать
переменную этого класса так, чтобы конструктор не был вызван. Если
класс имеет конструктор, не получающий параметров, то этот
конструктор будет вызываться в том случае, если в описании нет ни
одного параметра.
1.11 Вектора
Встоенное в C++ понятие вектора было разработано так, чтобы
обеспечить максимальную эффективность выполнения при минимальном
расходе памяти. Оно также (особенно когда используется совместно с
указателями) является весьма универсальным инструментом для
построения средств более высокого уровня. Вы могли бы, конечно,
возразить, что размер вектора должен задаваться как константа, что
нет проверки выхода за границы вектора и т.д. Ответ на подобные
возражения таков: "Вы можете запрограммировать это сами." Давайте
посмотрим, действительно ли оправдан такой ответ. Другими словами,
проверим средства абстракции языка C++, попытавшись реализовать эти
возможности для векторных типов, которые мы создадим сами, и
посмотрим, какие с этим связаны трудности, каких это требует
затрат, и насколько получившиеся векторные типы удобны в обращении.
- стр 37 -
class vector {
int* v;
int sz;
public:
vector(int); // конструктор
~vector(); // деструктор
int size() { return sz; }
void set_size(int);
int& operator[](int);
int& elem(int i) { return v[i]; }
};
Функция size возвращает число элементов вектора, таким образом
индексы должны лежать в диапазоне 0 ... size()-1. Функция set_size
сделана для изменения этого размера, elem обеспечивает доступ к
элементам без проверки индекса, а operator[] дает доступ с
проверкой границ.
Идея состоит в том, чтобы класс сам был структурой фиксированного
размера, управляющей доступом к фактической памяти вектора, которая
выделяется конструктором вектора с помощью распределителя свободной
памяти new:
vector::vector(int s)
{
if (s"=0) error("плохой размер вектора");
sz = s;
v = new int[s];
}
Тепрь вы можете описывать вектора типа vector почти столь же
элегантно, как и вектора, встроенные в сам язык:
vector v1(100);
vector v2(nelem*2-4);
Операцию доступа можно определить как
int& vector::operator[](int i)
{
if(i"0 || sz"=i) error("индекс выходит за границы");
return v[i];
}
Операция || (ИЛИИЛИ) - это логическая операция ИЛИ. Ее правый
операнд вычисляется только тогда, когда это необходимо, то есть
если вычисление левого операнда дало ноль. Возвращение ссылки
обеспечивает то, что запись [] может использоваться с любой стороны
операции присваивания:
v1[x] = v2[y];
Функция со странным именем ~vector - это деструктор, то есть
функция, описанная для того, чтобы она неявно вызывалась, когда
объект класса выходит из области видимости. Деструктор класса C
имеет имя ~C. Если его определить как
- стр 38 -
vector::~vector()
{
delete v;
}
то он будет, с помощью операции delete, освобождать пространство,
выделенное конструктором, поэтому когда vector выходит из области
видимости, все его пространство возвращается обратно в память для
дальнейшего использования.
1.12 Inline-подстановка
Если часто повторяется обращение к очень маленькой функции, то вы
можете начать беспокоиться о стоимости вызова функции. Обращение к
функции члену не дороже обращения к функции не члену с тем же
числом параметров (надо помнить, что функция член всегда имеет хотя
бы один параметр), и вызовы в функций в C++ примерно столь же
эффективны, сколь и в любом языке. Однако для слишком маленьких
функций может встать вопрос о накладных расходах на обращение. В
этом случае можно рассмотреть возможность спецификации функции как
inline-подставляемой. Если вы поступите таким образом, то
компилятор сгенерирует для функции соответствующий код в месте ее
вызова. Семантика вызова не изменяется. Если, например, size и elem
inline-подставляемые, то
vector s(100);
//...
i = s.size();
x = elem(i-1);
порождает код, эквивалентный
//...
i = 100;
x = s.v[i-1];
C++ компилятор обычно достаточно разумен, чтобы генерировать
настолько хороший код, насколько вы можете получить в результате
прямого макрорасширения. Разумеется, компилятор иногда вынужден
использовать временные переменные и другие уловки, чтобы сохранить
семантику.
Вы можете указать, что вы хотите, чтобы функция была inlineподставляемой,
поставив ключевое слово inline, или, для функции
члена, просто включив определение функции в описание класса, как
это сделано в предыдущем примере для size() и elem().
При хорошем использовании inline-функции резко повышают скорость
выполнения и уменьшают размер объектного кода. Однако, inlineфункции
запутывают описания и могут замедлить компиляцию, поэтому,
если они не необходимы, то их желательно избегать. Чтобы inlineфункция
давала существенный выигрыш по сравнению с обычной
функцией, она должна быть очень маленькой.
- стр 39 -
1.13 Производные классы
Теперь давайте определим вектор, для которого пользователь может
задавать границы изменения индекса.
class vec: public vector {
int low, high;
public:
vec(int,int);
int& elem(int);
int& operator[](int);
};
Определение vec как
:public vector
означает, в первую очередь, что vec это vector. То есть, тип vec
имеет (наследует) все свойства типа vector дополнительно к тем, что
описаны специально для него. Говорят, что класс vector является
базовым классом для vec, а о vec говорится, что он производный от
vector.
Класс vec модифицирует класс vector тем, что в нем задается
другой конструктор, который требует от пользователя указывать две
границы изменения индекса, а не длину, и имеются свои собственные
функции доступа elem(int) и operator[](int). Функция elem() класса
vec легко выражается через elem() класса vector:
int& vec::elem(int i)
{
return vector::elem(i-low);
}
Операция разрешения области видимости :: используется для того,
чтобы не было бесконечной рекурсии обращения к vec::elem() из нее
самой. с помощью унарной операции :: можно ссылаться на нелокальные
имена. Было бы разумно описать vec::elem() как inline, поскольку,
скорее всего, эффективность существенна, но необязательно,
неразумно и невозможно написать ее так, чтобы она непосредственно
использовала закрытый член v класса vector. Фунции производного
класса не имеют специального доступа к закрытым членам его базового
класса.
Конструктор можно написать так:
vec::vec(int lb, int hb) : (hb-lb+1)
{
if (hb-lb"0) hb = lb;
low = lb;
high = hb;
}
Запись : (hb-lb+1) используется для определения списка параметров
конструктора базового класса vector::vector(). Этот конструктор
вызывается перед телом vec::vec(). Вот небольшой пример, который
можно запустить, если скомпилировать его вместе с остальными
описаниями vector:
- стр 40 -
#include
void error(char* p)
{
cerr "" p "" "n\"; // cerr - выходной поток сообщений об
ошибках
exit(1);
}
void vector::set_size(int) { /* пустышка */ }
int& vec::operator[](int i)
{
if (i
1.14 Еще об операциях
Другое направление развития - снабдить вектора операциями:
- стр 41 -
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("плохой размер вектора для =");
for (int i = 0; i
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
1.15 Друзья (friend)
Функция operator+() не воздействует непосредственно на
представление вектора. Действтельно, она не может этого делать,
поскольку не является членом. Однако иногда желательно дать
функциям не членам возможность доступа к закрытой части класса.
Например, если бы не было функции "доступа без проверки"
vector::elem(), вам пришлось бы проверять индекс i на соответствие
границам три раза за каждый проход цикла. Здесь мы избежали этой
сложности, но она довольно типична, поэтому у класса есть механизм
предоставления права доступа к своей закрытой части функциям не
членам. Просто в описание класса помещается описание функции, перед
которым стоит ключевое слово friend. Например, если имеется
class Vec; // Vec - имя класса
class vector {
friend Vec operator+(Vec, Vec);
//...
};
- стр 43 -
То вы можете написать
Vec operator+(Vec a, Vec b)
{
int s = a.size();
if (s != b.size()) error("плохой размер вектора для +");
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, который я только что определил."
К сожалению, в C++ не предусмотрены средства для определения класса
векторов с типом элемента в качестве параметра. Один из способов -
продублировать описание и класса, и его функций членов. Это не
идеальный способ, но зачастую вполне приемлемый.
Вы можете воспользоваться препроцессором (#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) в результате расширения
превращается в определение функций, его можно использовать в
программе только один раз, в то время как 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 -
переопределять имя внутри блока для ссылки на другой о
...Закладка в соц.сетях
