Понятие класса, которому посвящена эта и три следующих главы, служитв С++ для того, чтобы дать программисту инструмент построения новыхтипов. Ими пользоваться не менее удобно, чем встроенными.В идеале использование определенного пользователем типа не должноотличаться от использования встроенных типов. Различия возможны тольков способе построения. Тип есть вполне конкретное представление некоторого понятия.Например, в С++ тип float с операциями +, -, * и т.д. являетсяхотя и ограниченным, но конкретным представлением математическогопонятия вещественного числа. Новый тип создается для того, чтобыстать специальным и конкретным представлением понятия, которое не находитпрямого и естественного отражения среди встроенных типов. Например,в программе из области телефонной связи можно ввести типtrunk_module (линия-связи), в видеоигре - тип explosion (взрыв),а в программе, обрабатывающей текст, - тип list_of_paragraphs(список-параграфов). Обычно проще понимать и изменять программу,в которой типы хорошо представляют используемые в задаче понятия.Удачно подобранное множество пользовательских типов делает программуболее ясной. Оно позволяет транслятору обнаруживать недопустимоеиспользование объектов, которое в противном случае останетсяневыявленным до отладки программы. Главное в определении нового типа - это отделить несущественныедетали реализации (например, расположение данных в объекте новоготипа) от тех его характеристик, которые существенны для правильногоего использования (например, полный список функций, имеющих доступк данным). Такое разделение обеспечивается тем, что вся работа соструктурой данных и внутрение, служебные операции над нею доступнытолько через специальный интерфейс (через "одно горло"). Глава состоит из четырех частей: $$5.2 Классы и члены. Здесь вводится основное понятие пользовательского типа, называемого классом. Доступ к объектам класса может ограничиваться множеством функций, описания которых входят в описание класса. Эти функции называются функциями-членами и друзьями. Для создания объектов класса используются специальные функции-члены, называемые конструкторами. Можно описать специальную функцию-член для удаления объектов класса при его уничтожении. Такая функция называется деструктором. $$5.3 Интерфейсы и реализации. Здесь приводятся два примера разработки, реализации и использования классов. $$5.4 Дополнительные свойства классов. Здесь приводится много дополнительных подробностей о классах. Показано, как функции, не являющейся членом класса, предоставить доступ к его частной части. Такую функцию называют другом класса. Вводятся понятия статических членов класса и указателей на члены класса. Здесь же показано, как определить дискриминирующее объединение. $$5.5 Конструкторы и деструкторы. Объект может создаваться как автоматический, статический или как объект в свободной памяти. Кроме того, объект может быть членом некоторого агрегата (массива или другого класса), который тоже можно размещать одним из этих трех способов. Подробно объясняется использование конструкторов и деструкторов, описывается применение определяемых пользователем функций размещения в свободной памяти и функций освобождения памяти.
Классы и члены
Класс - это пользовательский тип. Этот раздел знакомит с основнымисредствами определения класса, создания его объектов, работы стакими объектами и, наконец, удаления этих объектов послеиспользования.
Функции-члены
Посмотрим, как можно представить в языке понятие даты, используядля этого тип структуры и набор функций, работающих с переменнымиэтого типа: struct date { int month, day, year; }; date today; void set_date(date*, int, int, int); void next_date(date*); void print_date(const date*); //... Никакой явной связи между функциями и структурой date нет. Ее можноустановить, если описать функции как члены структуры: struct date { int month, day, year; void set(int, int, int); void get(int*, int* int*); void next(); void print(); }; Описанные таким образом функции называются функциями-членами. Их можновызывать только через переменные соответствующего типа, используястандартную запись обращения к члену структуры: date today; date my_birthday; void f() { my_birthday.set(30,12,1950); today.set(18,1,1991); my_birthday.print(); today.next(); } Поскольку разные структуры могут иметь функции-члены с одинаковымиименами, при определении функции-члена нужно указывать имя структуры: void date::next() { if (++day > 28) { // здесь сложный вариант } } В теле функции-члена имена членов можно использовать без указанияимени объекта. В таком случае имя относится к члену того объекта,для которого была вызвана функция.
Классы
Мы определили несколько функций для работы со структурой date, но из ееописания не следует, что это единственные функции, которыепредоставляют доступ к объектам типа date. Можно установить такоеограничение, описав класс вместо структуры: class date { int month, day, year; public: void set(int, int, int); void get(int*, int*, int*); void next(); void print() }; Служебное слово public (общий) разбивает описание класса на две части.Имена, описанные в первой частной (private) части класса, могутиспользоваться только в функциях-членах. Вторая - общая часть -представляет собой интерфейс с объектами класса. Поэтому структура - этотакой класс, в котором по определению все члены являются общими.Функции-члены класса определяются и используются точно так же, какбыло показано в предыдущем разделе: void date::print() // печать даты в принятом в США виде { cout << month << '/' << day << '/' << year; } Однако от функций не членов частные члены класса date уже ограждены: void backdate() { today.day--; // ошибка } Есть ряд преимуществ в том, что доступ к структуре данных ограниченявно указанным списком функций. Любая ошибка в дате (например,December, 36, 1985) могла быть внесена только функцией-членом,поэтому первая стадия отладки - локализация ошибки - происходитдаже до первого пуска программы. Это только частный случай общегоправила: любое изменение в поведении типа date может и должновызываться изменениями в его членах. Другое преимущество в том, чтопотенциальному пользователю класса для работы с ним достаточнознать только определения функций-членов. Защита частных данных основывается только на ограничениииспользования имен членов класса. Поэтому ее можно обойти спомощью манипуляций с адресами или явных преобразований типа,но это уже можно считать мошенничеством.
Ссылка на себя
В функции-члене можно непосредственно использовать имена членовтого объекта, для которого она была вызвана: class X { int m; public: int readm() { return m; } }; void f(X aa, X bb) { int a = aa.readm(); int b = bb.readm(); //... } При первом вызове readm() m обозначает aa.m, а при втором - bb.m. У функции-члена есть дополнительный скрытый параметр, являющийсяуказателем на объект, для которого вызывалась функция. Можно явноиспользовать этот скрытый параметр под именем this. Считается, чтов каждой функции-члене класса X указатель this описан неявно как X *const this; и инициализируется, чтобы указывать на объект, для которогофункция-член вызывалась. Этот указатель нельзя изменять, посколькуон постоянный (*const). Явно описать его тоже нельзя, т.к. this -это служебное слово. Можно дать эквивалентное описание класса X: class X { int m; public: int readm() { return this->m; } }; Для обращения к членам использовать this излишне. В основном thisиспользуется в функциях-членах, непосредственно работающих суказателями. Типичный пример - функция, которая вставляет элементв список с двойной связью: class dlink { dlink* pre; // указатель на предыдущий элемент dlink* suc; // указатель на следующий элемент public: void append(dlink*); //... }; void dlink::append(dlink* p) { p->suc = suc; // т.е. p->suc = this->suc p->pre = this; // явное использование "this" suc->pre = p; // т.е. this->suc->pre = p suc = p; // т.е. this->suc = p } dlink* list_head; void f(dlink* a, dlink* b) { //... list_head->append(a); list_head->append(b); } Списки с такой общей структурой служат фундаментом списочных классов, описываемых в главе 8. Чтобы присоединить звено к списку, нужно изменить объекты, на которые настроены указатели this, pre и suc. Все они имеют тип dlink, поэтому функция-член dlink::append() имеет к ним доступ. Защищаемой единицей в С++ является класс, а не отдельный объект класса. Можно описать функцию-член таким образом, что объект, для которого она вызывается, будет доступен ей только по чтению. Тот факт, что функция не будет изменять объект, для которого она вызывается (т.е. this*), обозначается служебным словом const в конце списка параметров: class X { int m; public: readme() const { return m; } writeme(int i) { m = i; } }; Функцию-член со спецификацией const можно вызывать для постоянных объектов, а функцию-член без такой спецификации - нельзя: void f(X& mutable, const X& constant) { mutable.readme(); // нормально mutable.writeme(7); // нормально constant.readme(); // нормально constant.writeme(7); // ошибка } В этом примере разумный транслятор смог бы обнаружить, что функция X::writeme() пытается изменить постоянный объект. Однако, это непростая задача для транслятора. Из-за раздельной трансляции он в общем случае не может гарантировать "постоянство" объекта, если нет соответствующего описания со спецификацией const. Например, определения readme() и writeme() могли быть в другом файле: class X { int m; public: readme() const; writeme(int i); }; В таком случае описание readme() со спецификацией const существенно. Тип указателя this в постоянной функции-члене класса X есть const X *const. Это значит, что без явного приведения с помощью this нельзя изменить значение объекта: class X { int m; public: //... void implicit_cheat() const { m++; } // ошибка void explicit_cheat() const { ((X*)this)->m++; } // нормально }; Отбросить спецификацию const можно потому, что понятие "постоянства" объекта имеет два значения. Первое, называемое "физическим постоянством" состоит в том, что объект хранится в защищенной от записи памяти. Второе, называемое "логическим постоянством" заключается в том, что объект выступает как постоянный (неизменяемый) по отношению к пользователям. Операция над логически постоянным объектом может изменить часть данных объекта, если при этом не нарушается его постоянство с точки зрения пользователя. Операциями, ненарушающими логическое постоянство объекта, могут быть буферизация значений, ведение статистики, изменение переменных-счетчиков в постоянных функциях-членах. Логического постоянства можно достигнуть приведением, удаляющим спецификацию const: class calculator1 { int cache_val; int cache_arg; //... public: int compute(int i) const; //... }; int calculator1::compute(int i) const { if (i == cache_arg) return cache_val; // нелучший способ ((calculator1*)this)->cache_arg = i; ((calculator1*)this)->cache_val = val; return val; } Этого же результата можно достичь, используя указатель на данные без const: struct cache { int val; int arg; }; class calculator2 { cache* p; //... public: int compute(int i) const; //... }; int calculator2::compute(int i) const { if (i == p->arg) return p->val; // нелучший способ p->arg = i; p->val = val; return val; } Отметим, что const нужно указывать как в описании, так и в определении постоянной функции-члена. Физическое постоянство обеспечивается помещением объекта в защищенную по записи память, только если в классе нет конструктора ($$7.1.6).
Инициализация
Инициализация объектов класса с помощью таких функций как set_date() - неэлегантное и чреватое ошибками решение. Поскольку явно не было указано, что объект требует инициализации, программист может либо забыть это сделать, либо сделать дважды, что может привести к столь же катастрофическим последствиям. Лучше дать программисту возможность описать функцию, явно предназначенную для инициализации объектов. Поскольку такая функция конструирует значение данного типа, она называется конструктором. Эту функцию легко распознать - она имеет то же имя, что и ее класс: class date { //... date(int, int, int); }; Если в классе есть конструктор, все объекты этого класса будут проинициализированы. Если конструктору требуются параметры, их надо указывать: date today = date(23,6,1983); date xmas(25,12,0); // краткая форма date my_birthday; // неправильно, нужен инициализатор Часто бывает удобно указать несколько способов инициализации объекта. Для этого нужно описать несколько конструкторов: class date { int month, day, year; public: //... date(int, int, int); // день, месяц, год date(int, int); // день, месяц и текущий год date(int); // день и текущие год и месяц date(); // стандартное значение: текущая дата date(const char*); // дата в строковом представлении }; Параметры конструкторов подчиняются тем же правилам о типах параметров, что и все остальные функции ($$4.6.6). Пока конструкторы достаточно различаются по типам своих параметров, транслятор способен правильно выбрать конструктор: date today(4); date july4("July 4, 1983"); date guy("5 Nov"); date now; // инициализация стандартным значением Размножение конструкторов в примере c date типично. При разработке класса всегда есть соблазн добавить еще одну возможность, - а вдруг она кому-нибудь пригодится. Чтобы определить действительно нужные возможности, надо поразмышлять, но зато в результате, как правило, получается более компактная и понятная программа. Сократить число сходных функций можно с помощью стандартного значения параметра. В примере с date для каждого параметра можно задать стандартное значение, что означает: "взять значение из текущей даты". class date { int month, day, year; public: //... date(int d =0, int m =0, y=0); //... }; date::date(int d, int m, int y) { day = d? d: today.day; month = m? m: today.month; year = y? y: today.year; // проверка правильности даты //... } Когда используется стандартное значение параметра, оно должно отличаться от всех допустимых значений параметра. В случае месяца и дня очевидно, что при значении нуль - это так, но неочевидно, что нуль подходит для значения года. К счастью, в европейском календаре нет нулевого года, т.к. сразу после 1 г. до р.х. (year==-1) идет 1 г. р.х. (year==1). Однако для обычной программы это, возможно, слишком тонкий момент. Объект класса без конструктора может инициализироваться присваиванием ему другого объекта этого же класса. Это незапрещено и в том случае, когда конструкторы описаны: date d = today; // инициализация присваиванием На самом деле, имеется стандартный конструктор копирования, определенный как поэлементное копирование объектов одного класса. Если такой конструктор для класса X не нужен, можно переопределить его как конструктор копирования X::X(const X&). Подробнее поговорим об этом в $$7.6.
Удаление
Пользовательские типы чаще имеют, чем не имеют, конструкторы, которые проводят надлежащую инициализацию. Для многих типов требуется и обратная операция - деструктор, гарантирующая правильное удаление объектов этого типа. Деструктор класса X обозначается ~X ("дополнение конструктора"). В частности, для многих классов используется свободная память (см. $$3.2.6), выделяемая конструктором и освобождаемая деструктором. Вот, например, традиционное определение типа стек, из которого для краткости полностью выброшена обработка ошибок: class char_stack { int size; char* top; char* s; public: char_stack(int sz) { top=s=new char[size=sz]; } ~char_stack() { delete[] s; } // деструктор void push(char c) { *top++ = c; } void pop() { return *--top; } }; Когда объект типа char_stack выходит из текущей области видимости, вызывается деструктор: void f() { char_stack s1(100); char_stack s2(200); s1.push('a'); s2.push(s1.pop()); char ch = s2.pop(); cout << ch << '\n'; } Когда начинает выполняться f(), вызывается конструктор char_stack, который размещает массив из 100 символов s1 и массив из 200 символов s2. При возврате из f() память, которая была занята обоими массивами, будет освобождена.
Подстановка
Программирование с классами предполагает, что в программе появится множество маленьких функций. По сути, всюду, где в программе с традиционной организацией стояло бы обычное обращение к структуре данных, используется функция. То, что было соглашением, стало стандартом, проверяемым транслятором. В результате программа может стать крайне неэффективной. Хотя вызов функции в C++ и не столь дорогостоящая операция по сравнению с другими языками, все-таки цена ее много выше, чем у пары обращений к памяти, составляющих тело тривиальной функции. Преодолеть эту трудность помогают функции-подстановки (inline). Если в описании класса функция-член определена, а не только описана, то она считается подстановкой. Это значит, например, что при трансляции функций, использующих char_stack из предыдущего примера, не будет использоваться никаких операций вызова функций, кроме реализации операций вывода! Другими словами, при разработке такого класса не нужно принимать во внимание затраты на вызов функций. Любое, даже самое маленькое действие, можно смело определять как функцию без потери эффективности. Это замечание снимает наиболее часто приводимый довод в пользу общих членов данных. Функцию-член можно описать со спецификацией inline и вне описания класса: class char_stack { int size; char* top; char* s; public: char pop(); //... }; inline char char_stack::pop() { return *--top; } Отметим, что недопустимо описывать разные определения функции-члена, являющейся подстановкой, в различных исходных файлах ($$R.7.1.2). Это нарушило бы понятие о классе как о цельном типе.
Интерфейсы и реализации
Что представляет собой хороший класс? Это нечто, обладающее хорошо определенным множеством операций. Нечто, рассматриваемое как "черный ящик", управлять которым можно только посредством этих операций. Нечто, чье фактическое представление можно изменить любым мыслимым способом, но не изменяя при этом способа использования операций. Нечто, что может потребоваться в нескольких экземплярах. Очевидные примеры хороших классов дают контейнеры разных видов: таблицы, множества, списки, вектора, словари и т.д. Такой класс имеет операцию занесения в контейнер. Обычно имеется и операция проверки: был ли данный член занесен в контейнер? Могут быть операции упорядочивания всех членов и просмотра их в определенном порядке. Наконец, может быть операция удаления члена. Обычно контейнерные классы имеют конструкторы и деструкторы.