Шилдт c++_базовый_курс издание 3. Герберт Шилдт С базовый курс
 Скачать 9.37 Mb.
|
В этой главе мы познакомимся с классом. Класс — это фундамент, на котором построена С++-поддержка объектно-ориентированного программирования, а также ядро многих более сложных программных средств. Класс — это базовая единица инкапсуляции, которая обеспечивает механизм создания объектов. Основы понятия класса Объектно-ориентированное программирование построено на понятии класса. Начнем с определения терминов класса и объекта. Класс определяет новый тип данных, который задает формат объекта. Класс включает как данные, так и код, предназначенный для выполнения над этими данными. Следовательно, класс связывает данные с кодом. В C++ спецификация класса используется для построения объектов. Объекты — это экземпляры класса. По сути, класс представляет собой набор планов, которые определяют, как строить объект. Важно понимать, что класс — это логическая абстракция, которая реально не существует до тех пор, пока не будет создан объект этого класса, т.е. то, что станет физическим представлением этого класса в памяти компьютера. Определяя класс, вы объявляете данные, которые он содержит, и код, который выполняется над этими данными. Хотя очень простые классы могут содержать только код или только данные, большинство реальных классов содержат оба компонента. В классе данные объявляются в виде переменных, а код оформляется в виде функций. Функции и переменные, составляющие класс, называются его членами. Таким образом, переменная, объявленная в классе, называется членом данных, а функция, объявленная в классе, называется функцией-членом. Иногда вместо термина член данных используется термин переменная экземпляра (или переменная реализации). Объявление класса начинается с ключевого слова class. Класс создается с помощью ключевого слова class. Объявление класса синтаксически подобно объявлению структуры. Рассмотрим пример. Следующий класс определяет тип queue, который предназначен для реализации очереди. (Под очередью понимается список с дисциплиной обслуживания в порядке поступления, т.е. "первым прибыл — первым обслужен".) // Создание класса queue. class queue { int q[100]; int sloc, rloc; public: void init(); void qput(int i); int qget(); }; Рассмотрим подробно объявление этого класса. По умолчанию члены класса являются закрытыми (private-членами). Все члены класса queue объявлены в теле инструкции class. Членами данных класса queue являются переменные q, sloc и rloc. Кроме того, здесь определено три функции-члена: init(), qput() и qget(). Любой класс может содержать как закрытые, так и открытые члены. По умолчанию все элементы, определенные в классе, являются закрытыми. Например, переменные q, sloc и rloc являются закрытыми. Это означает, что к ним могут получить доступ только другие члены класса queue; никакие другие части программы этого сделать не могут. В этом состоит одно из проявлений инкапсуляции: программист в полной мере может управлять доступом к определенным элементам данных. Закрытыми можно объявить и функции (в этом примере таких нет), и тогда их смогут вызывать только другие члены этого класса. Ключевое слово public используется для объявления открытых членов класса. Чтобы сделать части класса открытыми (т.е. доступными для других частей программы), необходимо объявить их после ключевого слова public. Все переменные или функции, определенные после спецификатора public, доступны для всех других функций программы. Итак, в классе queue функции init(), qput() и qget() являются открытыми. Обычно в программе организуется доступ к закрытым членам класса через его открытые функции. Обратите внимание на то, что после ключевого слова public стоит двоеточие. Следует иметь в виду, что объект образует своего рода связку между кодом и данными. Так, любая функция-член имеет доступ к закрытым элементам класса. Это означает, что функции init(), qput() и qget() имеют доступ к переменным q, sloc и rloc. Чтобы добавить функцию-член в класс, определите ее прототип в объявлении этого класса. Определив класс, можно создать объект этого "классового" типа, используя имя класса. Таким образом, имя класса становится спецификатором нового типа. Например, при выполнении следующей инструкции создается два объекта Q1 и Q2 типа queue, queue Q1, Q2; После создания объект класса будет иметь собственную копию членов данных, которые составляют класс. Это означает, что каждый из объектов Q1 и Q2 будет иметь собственные отдельные копии переменных q, sloc и rloc. Следовательно, данные, связанные с объектом Q1, отделены (изолированы) от данных, связанных с объектом Q2. Чтобы получить доступ к открытому члену класса через объект этого класса, используйте оператор "точка" (именно так это делается и при работе со структурами). Например, чтобы вывести на экран значение переменной sloc, принадлежащей объекту Q1, используйте следующую инструкцию. cout << Q1.sloc; Давайте вспомним: в C++ класс создает новый тип данных, который можно использовать для создания объектов. В частности, класс создает логическую конструкцию, которая определяет отношения между ее членами. Объявляя переменную класса, мы создаем объект. Объект характеризуется физическим существованием и является конкретным экземпляром класса. (Другими словами, объект занимает определенную область памяти, а определение типа — нет.) Более того, каждый объект класса имеет собственную копию данных, определенных в этом классе. В объявлении класса queue содержатся прототипы функций-членов. Поскольку функции- члены обеспечены своими прототипами в определении класса, их не нужно помещать больше ни в какое другое место программы. Чтобы реализовать функцию, которая является членом класса, необходимо сообщить компилятору, какому классу она принадлежит, квалифицировав имя этой функции с именем класса. Например, вот как можно записать код функции qput(). void queue::qput(int i) { if(sloc==100) { cout << "Очередь заполнена.\n"; return; } sloc++; q[sloc] = i; } Оператор разрешения области видимости квалифицирует имя члена вместе с именем его класса. Оператор "::" называется оператором разрешения области видимости. По сути, он сообщает компилятору, что данная версия функции qput() принадлежит классу queue. Другими словами, оператор "::" заявляет о том, что функция qput() находится в области видимости класса queue. Различные классы могут использовать одинаковые имена функций. Компилятор же определит, к какому классу принадлежит функция, с помощью оператора разрешения области видимости и имени класса. Функции-члены можно вызывать только относительно заданного объекта. Чтобы вызвать функцию-член из части программы, которая находится вне класса, необходимо использовать имя объекта и оператор "точка". Например, при выполнении этого кода будет вызвана функция init() для объекта ob1. queue ob1, ob2; ob1.init(); При вызове функции ob1.init() действия, определенные в функции init(), будут направлены на копии данных, относящиеся к объекту ob1. Следует иметь в виду, что ob1 и ob2 — это два отдельных объекта. Это означает, что, например, инициализация объекта ob1 отнюдь не приводит к инициализации объекта ob2. Единственное, что связывает объекты ob1 и ob2, состоит в том, что они имеют один и тот же тип. Если одна функция-член вызывает другую функцию-член того же класса, не нужно указывать имя объекта и использовать оператор "точка". В этом случае компилятор уже точно знает, какой объект подвергается обработке. Имя объекта и оператор "точка" необходимы только тогда, когда функция-член вызывается кодом, расположенным вне класса. По тем же причинам функция-член может непосредственно обращаться к любому члену данных своего класса, но код, расположенный вне класса, должен обращаться к переменной класса, используя имя объекта и оператор "точка". В приведенной ниже программе класс queue иллюстрируется полностью (для этого объединены все уже знакомые вам части кода и добавлены недостающие детали). #include using namespace std; // Создание класса queue. class queue { int q[100]; int sloc, rloc; public: void init(); void qput(int i); int qget(); }; // Инициализация класса queue. void queue::init() { rloc = sloc = 0; } // Занесение в очередь целочисленного значения. void queue::qput(int i) { if(sloc==100) { cout << "Очередь заполнена.\n"; return; } sloc++; q[sloc] = i; } // Извлечение из очереди целочисленного значения. int queue::qget() { if(rloc == sloc) { cout << "Очередь пуста.\n"; return 0; } rloc++; return q[rloc]; } int main() { queue a, b; // Создание двух объектов класса queue. а.init(); b.init(); a.qput(10); b.qput(19); a.qput(20); b.qput(1); cout << "Содержимое очереди a: "; cout << a.qget() << " "; cout << a.qget() << "\n"; cout << "Содержимое очереди b: "; cout << b.qget() << " "; cout << b.qget() << "\n"; return 0; } При выполнении эта программа генерирует такие результаты. Содержимое очереди а: 10 20 Содержимое очереди b: 19 1 Не забывайте, что закрытые члены класса доступны только функциям, которые являются членами этого класса. Например, такую инструкцию а.rloc = 0; нельзя включить в функцию main() нашей программы. Общий формат объявления класса Все классы объявляются подобно приведенному выше классу queue. Общий формат объявления класса имеет следующий вид. class имя_класса { закрытые данные и функции public: открытые данные и функции } список_объектов; Здесь элемент имя_класса означает имя класса. Это имя становится именем нового типа, которое можно использовать для создания объектов класса. Объекты класса можно создать путем указания их имен непосредственно за закрывающейся фигурной скобкой объявления класса (в качестве элемента список_объектов), но это необязательно. После объявления класса его элементы можно создавать по мере необходимости. Доступ к членам класса Получение доступа к членам класса — вот что часто приводит в замешательство начинающих программистов. Поэтому остановимся на этой теме подробнее. Итак, рассмотрим следующий простой класс. // Демонстрация доступа к членам класса. #include using namespace std; class myclass { int a; // закрытые данные public: int b; // открытые данные void setab(int i); // открытые функции int geta(); void reset(); }; void myclass::setab(int i) { a = i; // прямое обращение к переменной а b = i*i; // прямое обращение к переменной b } int myclass::geta() { return a; // прямое обращение к переменной а } void myclass::reset() { // Прямой вызов функции setab() setab(0); // для уже известного объекта. } int main() { myclass ob; ob.setab(5); // Устанавливаем члены данных ob.a и ob.b. cout << "Объект ob после вызова функции setab(5): "; cout << ob.geta() << ' '; cout << ob.b; // К члену b можно получить прямой доступ, поскольку он является public-членом. cout << '\n'; ob.b = 20; // Член b можно установить напрямую, поскольку он является public-членом. cout << "Объект ob после установки члена ob.b=20: "; cout << ob.geta() <<' '; cout << ob.b; cout << '\n'; ob.reset(); cout << "Объект ob после вызова функции ob.reset(): "; cout << ob.geta() << ' '; cout << ob.b; cout << '\n'; return 0; } При выполнении этой программы получаем следующие результаты. Объект ob после вызова функции setab(5): 5 25 Объект ob после установки члена ob.b=20: 5 20 Объект ob после вызова функции ob.reset(): 0 0 Теперь рассмотрим, как осуществляется доступ к членам класса myclass. Прежде всего обратите внимание на то, что для присвоения значений переменным а и b в функции setab() используются следующие строки кода. а = i; // прямое обращение к переменной а b = i*i; // прямое обращение к переменной b Поскольку функция setab() является членом класса, она может обращаться к членам данных а и b того же класса непосредственно, без явного указания имени объекта (и не используя оператор "точка"). Как упоминалось выше, функция-член всегда вызывается для определенного объекта (а коль вызов состоялся, объект, стало быть, известен). Таким образом, в теле функции-члена нет необходимости указывать объект вторично. Следовательно, ссылки на переменные а и b будут применяться к копиям этих переменных, относящимся к вызывающему объекту. Теперь обратите внимание на то, что переменная b — открытый (public) член класса myclass. Это означает, что к b можно получить доступ из кода, определенного вне тела класса myclass. Следующая строка кода из функции main(), при выполнении которой переменной b присваивается число 20, демонстрирует реализацию такого прямого доступа. ob.b = 20; // К члену b можно получить прямой доступ. // поскольку он является public-членом. Поскольку эта инструкция не принадлежит телу класса myclass, то к переменной b возможен доступ только с использованием конкретного объекта (в данном случае объекта ob) и оператора "точка". Теперь обратите внимание на то, как вызывается функция-член reset() из функции main(). ob.reset(); Поскольку функция reset() является открытым членом класса, ее также можно вызвать из кода, определенного вне тела класса myclass, и посредством конкретного объекта (в данном случае объекта ob). Наконец, рассмотрим код функции reset(). Тот факт, что она является функцией-членом, позволяет ей непосредственно обращаться к другим членам того же класса, не используя оператор "точка" или конкретный объект. В данном случае она вызывает функцию-член setab(). И снова-таки, поскольку объект уже известен (он используется для вызова функции reset()), нет никакой необходимости указывать его еще раз. Здесь важно понять следующее: когда доступ к некоторому члену класса происходит извне этого класса, его необходимо квалифицировать (уточнить) с помощью имени конкретного объекта. Но код самой функции-члена может обращаться к другим членам того же класса напрямую. На заметку. Не стоит волноваться, если вы еще не почувствовали в себе уверенность в вопросах получения доступа к членам класса. Небольшое беспокойство при освоении этой темы — обычное явление для начинающих программистов. Смело продолжайте читать книгу, рассматривая как можно больше примеров, и тема доступа к членам класса вскоре станет такой же простой, как таблица умножения! Конструкторы и деструкторы Конструктор — это функция, которая вызывается при создании объекта. Как правило, некоторую часть объекта, прежде чем его можно будет использовать, необходимо инициализировать. Например, рассмотрим класс queue (он представлен выше в этой главе). Прежде чем класс queue можно будет использовать, переменным rloc и sloc нужно присвоить нулевые значения. В данном конкретном случае это требование выполнялось с помощью функции init(). Но, поскольку требование инициализации членов класса весьма распространено, в C++ предусмотрена реализация этой возможности при создании объектов класса. Такая автоматическая инициализация выполняется благодаря использованию конструктора. Конструктор — это специальная функция, которая является членом класса и имя которой совпадает с именем класса. Вот, например, как стал выглядеть класс queue после переделки, связанной с применением конструктора для инициализации его членов. // Определение класса queue. class queue { int q[100]; int sloc, rloc; public: queue(); // конструктор void qput(int i); int qget(); }; Обратите внимание на то, что в объявлении конструктора queue() отсутствует тип возвращаемого значения. В C++ конструкторы не возвращают значений и, следовательно, нет смысла в указании их типа. (При этом нельзя указывать даже тип void.) Теперь приведем код функции queue(). // Определение конструктора. queue::queue() { sloc = rloc = 0; cout << "Очередь инициализирована.\n"; } В данном случае при выполнении конструктора выводится сообщение Очередь инициализирована., которое служит исключительно иллюстративным целям. На практике же в большинстве случаев конструкторы не выводят никаких сообщений. Конструктор объекта вызывается при создании объекта. Это означает, что он вызывается при выполнении инструкции объявления объекта. Конструкторы глобальных объектов вызываются в самом начале выполнения программы, еще до обращения к функции main(). Что касается локальных объектов, то их конструкторы вызываются каждый раз, когда встречается объявление такого объекта. Деструктор — это функция, которая вызывается при разрушении объекта. Дополнением к конструктору служит деструктор. Во многих случаях при разрушении объекту необходимо выполнить некоторое действие или даже некоторую последовательность действий. Локальные объекты создаются при входе в блок, в котором они определены, и разрушаются при выходе из него. Глобальные объекты разрушаются при завершении программы. Существует множество факторов, обуславливающих необходимость деструктора. Например, объект должен освободить ранее выделенную для него память. В C++ именно деструктору поручается обработка процесса дезактивизации объекта. Имя деструктора совпадает с именем конструктора, но предваряется символом "" Подобно конструкторам деструкторы не возвращают значений, а следовательно, в их объявлениях отсутствует тип возвращаемого значения. Рассмотрим уже знакомый нам класс queue, но теперь он содержит конструктор и деструктор. (Справедливости ради отметим, что классу queue деструктор, по сути, не нужен, а его наличие здесь можно оправдать лишь иллюстративными целями.) // Определение класса queue. class queue { int q[100]; int sloc, rloc; public: queue(); // конструктор queue(); // деструктор void qput(int i); int qget(); }; // Определение конструктора. queue::queue() { sloc = rloc = 0; cout << "Очередь инициализирована.\n"; } // Определение деструктора. queue::queue() { cout << "Очередь разрушена.\n"; } Вот как выглядит новая версия программы реализации очереди, в которой демонстрируется использование конструктора и деструктора. // Демонстрация использования конструктора и деструктора. #include using namespace std; // Определение класса queue. class queue { int q[100]; int sloc, rloc; public: queue(); // конструктор queue(); // деструктор void qput(int i); int qget(); }; // Определение конструктора. queue::queue() { sloc = rloc = 0; cout << "Очередь инициализирована.\n"; } // Определение деструктора. queue::queue() { cout << "Очередь разрушена.\n"; } // Занесение в очередь целочисленного значения. void queue::qput(int i) { if(sloc==100) { cout << "Очередь заполнена.\n"; return; } sloc++; q[sloc] = i; } // Извлечение из очереди целочисленного значения. int queue::qget() { if(rloc == sloc) { cout << "Очередь пуста.\n"; return 0; } rloc++; return q[rloc]; } int main() { queue a, b; // Создание двух объектов класса queue. a.qput(10); b.qput(19); a.qput(20); b.qput(1); cout << a.qget() << " "; cout << a.qget() << "\n"; cout << b.qget() << " "; cout << b.qget() << "\n"; return 0; } При выполнении этой программы получаются такие результаты. Очередь инициализирована. Очередь инициализирована. 10 20 19 1 Очередь разрушена. Очередь разрушена. Параметризованные конструкторы Конструктор может иметь параметры. С их помощью при создании объекта членам данных (переменным класса) можно присвоить некоторые начальные значения, определяемые в программе. Это реализуется путем передачи аргументов конструктору объекта. В следующем примере мы усовершенствуем класс queue так, чтобы он принимал аргументы, которые будут служить идентификационными номерами (ID) очереди. Прежде всего необходимо внести изменения в определение класса queue. Теперь оно выглядит так. // Определение класса queue. class queue { int q[100]; int sloc, rloc; int who; // содержит идентификационный номер очереди public: queue(int id); // параметризованный конструктор queue(); // деструктор void qput(int i); int qget(); }; Переменная who используется для хранения идентификационного номера (ID) создаваемой программой очереди. Ее реальное значение определяется значением, передаваемым конструктору в качестве параметра id, при создании переменной типа queue. Конструктор queue() выглядит теперь следующим образом. // Определение конструктора. queue::queue(int id) { sloc = rloc = 0; who = id; cout << "Очередь " << who << " инициализирована.\n"; } Чтобы передать аргумент конструктору, необходимо связать этот аргумент с объектом при объявлении объекта. C++ поддерживает два способа реализации такого связывания. Вот как выглядит первый способ. queue а = queue (101); В этом объявлении создается очередь с именем a, которой передается значение (идентификационный номер) 101. Но эта форма (в таком контексте) используется редко, поскольку второй способ имеет более короткую запись и удобнее для использования. Во втором способе аргумент должен следовать за именем объекта и заключаться в круглые скобки. Например, следующая инструкция эквивалентна предыдущему объявлению, queue а (101); Это самый распространенный способ объявления параметризованных объектов. Опираясь на этот метод, приведем общий формат передачи аргументов конструкторам. тип_класса имя_переменной(список_аргументов); Здесь элемент список_аргументов представляет собой список разделенных запятыми аргументов, передаваемых конструктору. На заметку. Формально между двумя приведенными выше формами инициализации существует небольшое различие, которое вы поймете при дальнейшем чтении этой книги. Но это различие не влияет на результаты выполнения программ, представленных в этой главе. В следующей версии программы организации очереди демонстрируется использование параметризованного конструктора. // Использование параметризованного конструктора. #include using namespace std; // Определение класса queue. class queue { int q[100]; int sloc, rloc; int who; // содержит идентификационный номер очереди public: queue(int id); // параметризованный конструктор queue(); // деструктор void qput(int i); int qget(); }; // Определение конструктора. queue::queue(int id) { sloc = rloc = 0; who = id; cout << "Очередь " << who << " инициализирована.\n"; } // Определение деструктора. queue::queue() { cout << "Очередь " << who << " разрушена.\n"; } // Занесение в очередь целочисленного значения. void queue::qput(int i) { if(sloc==100) { cout << "Очередь заполнена.\n"; return; } sloc++; q[sloc] = i; } // Извлечение из очереди целочисленного значения. int queue::qget() { if(rloc == sloc) { cout << "Очередь пуста.\n"; return 0; } rloc++; return q[rloc]; } int main() { queue a(1), b(2); // Создание двух объектов класса queue. a.qput(10); b.qput(19); a.qput(20); return 0; } При выполнении эта версия программы генерирует такие результаты: Очередь 1 инициализирована. Очередь 2 инициализирована. 10 20 19 1 Очередь 2 разрушена. Очередь 1 разрушена. Как видно из кода функции main(), очереди, связанной с именем а, присваивается идентификационный номер 1, а очереди, связанной с именем b, — идентификационный номер 2. Несмотря на то что в примере с использованием класса queue при создании объекта передается только один аргумент, в общем случае возможна передача двух аргументов и более. В следующем примере объектам типа widget передается два значения. #include using namespace std; class widget { int i; int j; public: widget(int a, int b); void put_widget(); }; // Передаем 2 аргумента конструктору widget(). widget::widget(int a, int b) { i = a; j = b; } void widget::put_widget() { cout << i << " " << j << "\n"; } int main() { widget x(10, 20), y(0, 0); x.put_widget(); у.put_widget(); return 0; } Важно! В отличие от конструкторов, деструкторы не могут иметь параметров. Причину понять нетрудно: не существует средств передачи аргументов объекту, который разрушается. Если же у вас возникнет та редкая ситуация, когда при вызове деструктора вашему объекту необходимо получить доступ к некоторым данным, определяемым только во время выполнения программы, создайте для этой цели специальную переменную. Затем непосредственно перед разрушением объекта установите эту переменную равной нужному значению. При выполнении эта программа отображает следующие результаты. 10 20 0 0 Альтернативный вариант инициализации объекта Если конструктор принимает только один параметр, можно использовать альтернативный способ инициализации членов объекта. Рассмотрим следующую программу. #include using namespace std; class myclass { int a; public: myclass(int x); int get_a(); }; myclass::myclass(int x) { a = x; } int myclass::get_a() { return a; } int main() { myclass ob = 4; // вызов функции myclass(4) cout << ob.get_a(); return 0; } Здесь конструктор для объектов класса myclass принимает только один параметр. Обратите внимание на то, как в функции main() объявляется объект ob. Для этого используется такой формат объявления: myclass ob = 4; В этой форме инициализации объекта число 4 автоматически передается параметру х при вызове конструктора myclass(). Другими словами, эта инструкция объявления обрабатывается компилятором так, как если бы она была записана следующим образом. myclass ob = myclass(4); В общем случае, если у вас есть конструктор, который принимает только один аргумент, для инициализации объекта вы можете использовать либо вариант ob(х), либо вариант ob=х. Дело в том, что при создании конструктора с одним аргументом неявно создается преобразование из типа этого аргумента в тип этого класса. Помните, что показанный здесь альтернативный способ инициализации объектов применяется только к конструкторам, которые имеют только один параметр. Классы и структуры — родственные типы Как упоминалось в предыдущей главе, в C++ структура также обладает объектно- ориентированными возможностями. В сущности, классы и структуры можно назвать близкими родственниками. За одним исключением, они взаимозаменяемы, поскольку структура также может включать данные и код, который манипулирует этими данными точно так же, как это может делать класс. Единственное различие между С++-структурой и С++-классом состоит в том, что по умолчанию члены класса являются закрытыми, а члены структуры — открытыми. В остальном же структуры и классы имеют одинаковое назначение. На самом деле в соответствии с формальным синтаксисом C++ объявление структуры создает тип класса. Рассмотрим пример структуры со свойствами, подобными свойствам класса. // Использование структуры для создания класса. #include using namespace std; struct cl { int get_i(); // Эти члены открыты (public) void put_i(int j); // по умолчанию. private: int i; }; int cl::get_i() { return i; } void cl::put_i(int j) { i = j; } int main() { cl s; s.put_i (10); cout << s.get_i(); return 0; } В этой программе определяется тип структуры с именем cl, в которой функции-члены get_i() и put_i() являются открытыми (public), а член данных i — закрытым (private). Обратите внимание на то, что в структурах для объявления закрытых членов используется ключевое слово private. Ключевое слово private используется для объявления закрытых членов класса. В следующем примере показана эквивалентная программа, которая использует вместо типа struct тип class. // Использование типа class вместо типа struct. #include using namespace std; class cl { int i; // закрытый член по умолчанию public: int get_i(); void put_i(int j); }; int cl::get_i() { return i; } void cl::put_i(int j) { i = j; } int main() { cl s; s.put_i(10); cout << s.get_i(); return 0; } Иногда С++-программисты к структурам, которые не содержат функции-члены, применяют термин POD-struct. С++-программисты тип class используют главным образом для определения формы объекта, который содержит функции-члены, а тип struct — для создания объектов, которые содержат только члены данных. Иногда для описания структуры, которая не содержит функции-члены, используется аббревиатура POD (Plain Old Data). Сравнение структур с классами Тот факт, что и структуры, и классы обладают практически идентичными возможностями, создает впечатление избыточности. Многие новички в программировании на C++ недоумевают, почему в нем существует такое очевидное дублирование. Нередко приходится слышать предложения отказаться от ненужного ключевого слова (class или struct) и оставить только одно из них. Ответ на эту цепь рассуждений лежит в происхождении языка C++ от С и намерении сохранить C++ совместимым снизу вверх с С. В соответствии с современным определением C++ стандартная С-структура одновременно является совершенно законной С++-структурой. В языке С, который не содержит ключевых слов public или private, все члены структуры являются открытыми. Вот почему и члены С++-структур по умолчанию являются открытыми (а не закрытыми). Поскольку конструкция типа class специально разработана для поддержки инкапсуляции, есть определенный смысл в том, чтобы по умолчанию ее члены были закрытыми. Следовательно, чтобы избежать несовместимости с языком С в этом вопросе, аспекты доступа, действующие по умолчанию, менять было нельзя, поэтому и решено было добавить новое ключевое слово. Но в перспективе можно говорить о более веской причине для отделения структур от классов. Поскольку тип class синтаксически отделен от типа struct, определение класса вполне открыто для эволюционных изменений, которые синтаксически могут оказаться несовместимыми с С-подобными структурами. Поскольку мы имеем дело с двумя отдельными типами, будущее направление развития языка C++ не обременяется "моральными обязательствами", связанными с совместимостью с С-структурами. Под "занавес" этой темы отметим следующее. Структура определяет тип класса. Следовательно, структура является классом. На этом настаивал создатель языка C++, Бьерн Страуструп. Он полагал, что если структура и классы будут более или менее эквивалентны, то переход от С к C++ станет проще. И история доказала его правоту! Объединения и классы — родственные типы Тот факт, что структуры и классы — родственны, обычно никого не удивляет; однако вы можете удивиться, узнав, что объединения также связаны с классами "близкими отношениями". Согласно определению C++ объединение — это, по сути, тот же класс, в котором все члены данных хранятся в одной и той же области. (Таким образом, объединение также определяет тип класса.) Объединение может содержать конструктор и деструктор, а также функции-члены. Конечно же, члены объединения по умолчанию открыты (public), а не закрыты (private). Рассмотрим программу, в которой объединение используется для отображения символов, составляющих содержимое старшего и младшего байтов короткого целочисленного значения (предполагается, что короткие целочисленные значения занимают в памяти компьютера два байта). // Создание класса на основе объединения. #include using namespace std; union u_type { u_type(short int a); // открытые члены по умолчанию void showchars(); short int i; char ch[2]; }; // конструктор u_type::u_type(short int a) { i = a; } // Отображение символов, составляющих значение типа short int. void u_type::showchars() { cout << ch[0] << " "; cout << ch[1] << "\n"; } int main() { u_type u(1000); u.showchars(); return 0; } Подобно структуре, С++-объединение также произошло от своего С-предшественника. Но в C++ оно имеет более широкие "классовые" возможности. Однако лишь то, что C++ наделяет "свои" объединения более могучими средствами и большей степенью гибкости, не означает, что вы непременно должны их использовать. Если вас вполне устраивает объединение с традиционным стилем поведения, вы вольны именно таким его и использовать. Но в случаях, когда можно инкапсулировать данные объединения вместе с функциями, которые их обрабатывают, все же стоит воспользоваться С++-возможностями, что придаст вашей программе дополнительные преимущества. Встраиваемые функции Прежде чем мы продолжим освоение класса, сделаем небольшое, но важное отступление. Оно не относится конкретно к объектно-ориентированному программированию, но является очень полезным средством C++, которое довольно часто используется в определениях классов. Речь идет о встраиваемой, или подставляемой, функции (inline function). Встраиваемой называется функция, код которой подставляется в то место строки программы, из которого она вызывается, т.е. вызов такой функции заменяется ее кодом. Существует два способа создания встраиваемой функции. Первый состоит в использовании модификатора inline. Например, чтобы создать встраиваемую функцию f(), которая возвращает int-значение и не принимает ни одного параметра, достаточно объявить ее таким образом. inline int f() { // ... } Модификатор inline должен предварять все остальные аспекты объявления функции. Встраиваемая функция — это небольшая (по объему кода) функция, код которой подставляется вместо ее вызова. Причиной существования встраиваемых функций является эффективность. Ведь при каждом вызове обычной функции должна быть выполнена целая последовательность инструкций, связанных с обработкой самого вызова, включающего помещение ее аргументов в стек, и с возвратом из функции. В некоторых случаях значительное количество циклов центрального процессора используется именно для выполнения этих действий. Но если функция встраивается в строку программы, подобные системные затраты попросту отсутствуют, и общая скорость выполнения программы возрастает. Если же встраиваемая функция оказывается не такой уж маленькой, общий размер программы может существенно увеличиться. Поэтому лучше всего в качестве встраиваемых использовать только очень маленькие функции, а те, что побольше, — оформлять в виде обычных. Продемонстрируем использование встраиваемой функции на примере следующей программы. #include using namespace std; class cl { int i; // закрытый член по умолчанию public: int get_i(); void put_i(int j); }; inline int cl::get_i() { return i; } inline void cl::put_i(int j) { i = j; } int main() { cl s; s.put_i(10); cout << s.get_i(); return 0; } Здесь вместо вызова функций get_i() и put_i() подставляется их код. Так, в функции main() строка s.put_i(10); функционально эквивалентна следующей инструкции присваивания: s.i = 10; Поскольку переменная i по умолчанию закрыта в рамках класса cl, эта строка не может реально существовать в коде функции main(), но за счет встраивания функции put_i() мы достигли того же результата, одновременно избавившись от затрат системных ресурсов, связанных с вызовом функции. Важно понимать, что в действительности использование модификатора inline является запросом, а не командой, по которой компилятор сгенерирует встраиваемый (inline-) код. Существуют различные ситуации, которые могут не позволить компилятору удовлетворить наш запрос. Вот несколько примеров. ■ Некоторые компиляторы не генерируют встраиваемый код, если соответствующая функция содержит цикл, конструкцию switch или инструкцию goto. ■ Чаще всего встраиваемыми не могут быть рекурсивные функции. ■ Как правило, встраивание "не проходит" для функций, которые содержат статические (static) переменные. Узелок на память. Ограничения на использование встраиваемых функций зависят от конкретной реализации системы, поэтому, чтобы узнать, какие ограничения имеют место в вашем случае, обратитесь к документации, прилагаемой к вашему компилятору. Использование встраиваемых функций в определении класса Существует еще один способ создания встраиваемой функции. Он состоит в определении кода для функции-члена класса в самом объявлении класса. Любая функция, которая определяется в объявлении класса, автоматически становится встраиваемой. В этом случае необязательно предварять ее объявление ключевым словом inline. Например, предыдущую программу можно переписать в таком виде. #include using namespace std; class cl { int i; // закрытый член по умолчанию public: // автоматически встраиваемые функции int get_i() { return i; } void put_i(int j) { i = j; } }; int main() { s.put_i(10); cout << s.get_i(); return 0; } Здесь функции get_i() и put_i() определены в теле объявления класса cl и автоматически являются встраиваемыми. Обратите внимание на то, как выглядит код функций, определенных "внутри" класса cl. Для очень небольших по объему функций такое представление кода отражает обычный стиль языка C++. Однако можно сформатировать эти функции и таким образом. class cl { int i; // закрытый член по умолчанию public: // встраиваемые функции int get_i() { return i; } void put_i(int j) { i = j; } }; В общем случае небольшие функции (как представленные в этом примере) определяются в объявлении класса. Это соглашение применяется и к остальным примерам данной книги. Важно! Определение небольших функций-членов в объявлении класса — обычная практика в С++-программировании. И дело даже не в средстве автоматического встраивания, а просто в удобстве. Вряд ли вы встретите в профессиональных программах, чтобы короткие функции-члены определялись вне их класса. Массивы объектов Массивы объектов можно создавать точно так же, как создаются массивы значений других типов. Например, в следующей программе создается класс display, который содержит значения разрешения для различных режимов видеомонитора. В функции main() создается массив для хранения трех объектов типа display, а доступ к объектам, которые являются элементами этого массива, осуществляется с помощью обычной процедуры индексирования массива. // Пример использования массива объектов. #include using namespace std; enum resolution {low, medium, high} class display { int width; int height; resolution res; public: void set_dim(int w, int h) {width=w; height=h;} void get_dim(int &w, int &h) {w=width; h=height;} void set_res(resolution r) {res = r;} resolution get_res() {return res;} }; char names[3][8] = { "низкий", "средний", "высокий", }; int main() { display display_mode[3]; int i, w, h; display_mode[0].set_res(low); display_mode[0].set_dim(640, 480); display_mode[1].set_res(medium); display_mode[1].set_dim(800, 600); display_mode[2].set_res(high); display_mode[2].set_dim(1600, 1200); cout << "Возможные режимы отображения данных:\n\n"; for(i=0; i<3; i++) { cout << names[display_mode[i].get_res()] << ":"; display_mode[i].get_dim(w, h); cout << w << " x " << h << "\n"; } return 0; } При выполнении эта программа генерирует такие результаты. Возможные режимы отображения данных: низкий: 640 х 480 средний: 800 х 600 высокий: 1600 х 1200 Обратите внимание на использование двумерного символьного массива names для преобразования перечислимого значения в эквивалентную символьную строку. Во всех перечислениях, которые не содержат явно заданной инициализации, первая константа имеет значение 0, вторая — значение 1 и т.д. Следовательно, значение, возвращаемое функцией get_res(), можно использовать для индексации массива names, что позволяет вывести на экран соответствующее название режима отображения. Многомерные массивы объектов индексируются точно так же, как многомерные массивы значений других типов. Инициализация массивов объектов Если класс включает параметризованный конструктор, то массив объектов такого класса можно инициализировать. Например, в следующей программе используется параметризованный класс samp и инициализируемый массив sampArray объектов этого класса. // Инициализация массива объектов. #include using namespace std; class samp { int a; public: samp(int n) { a = n; } int get_a() { return a; } }; int main() { samp sampArray[4] = { -1, -2, -3, -4 }; int i; for(i=0; i<4; i++) cout << sampArray[i].get_a() << ' '; cout << "\n"; return 0; } Результаты выполнения этой программы -1 -2 -3 -4 подтверждают, что конструктору samp действительно были переданы значения от -1 до -4. В действительности синтаксис инициализации массива, выраженный строкой samp sampArray[4] = { -1, -2, -3, -4 }; представляет собой сокращенный вариант следующего (более длинного) формата: samp sampArray[4] = { samp(-1), samp(-2), samp(-3), samp(-4) }; Формат инициализации, представленный в программе, используется программистами чаще, чем его более длинный эквивалент, однако следует помнить, что он работает для массивов таких объектов, конструкторы которых принимают только один аргумент. При инициализации массива объектов, конструкторы которых принимают несколько аргументов, необходимо использовать более длинный формат инициализации. Рассмотрим пример. #include using namespace std; class samp { int a, b; public: samp(int n, int m) { a = n; b = m; } int get_a() { return a; } int get_b() { return b; } }; int main() { samp sampArray[4][2] = { samp(1, 2), samp(3, 4), samp(5, 6), samp(7, 8), samp(9, 10), samp(11, 12), samp(13, 14), samp(15, 16) }; int i; for(i=0; i<4; i++) { cout << sampArray[i][0].get_a() << ' '; cout << sampArray[i][0].get_b() << "\n"; cout << sampArray[i][1].get_a() << ' '; cout << sampArray[i][1].get_b() << "\n"; } cout << "\n"; return 0; } В этом примере конструктор класса samp принимает два аргумента. В функции main() объявляется и инициализируется массив sampArray путем непосредственных вызовов конструктора samp(). Инициализируя массивы, можно всегда использовать длинный формат инициализации, даже если объект принимает только один аргумент (короткая форма просто более удобна для применения). Нетрудно проверить, что при выполнении эта программа отображает такие результаты. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Указатели на объекты Как было показано в предыдущей главе, доступ к структуре можно получить напрямую или через указатель на эту структуру. Аналогично можно обращаться и к объекту: непосредственно (как во всех предыдущих примерах) или с помощью указателя на объект. Чтобы получить доступ к отдельному члену объекта исключительно "силами" самого объекта, используется оператор "точка". А если для этого служит указатель на этот объект, необходимо использовать оператор "стрелка". (Применение операторов "точка" и "стрелка" для объектов соответствует их применению для структур и объединений.) Чтобы объявить указатель на объект, используется тот же синтаксис, как и в случае объявления указателей на значения других типов. В следующей программе создается простой класс Р_ехample, определяется объект этого класса ob и объявляется указатель на объект типа Р_ехample с именем р. В этом примере показано, как можно напрямую получить доступ к объекту ob и как использовать для этого указатель (в этом случае мы имеем дело с косвенным доступом). // Простой пример использования указателя на объект. #include using namespace std; class P_example { int num; public: void set_num(int val) {num = val;} void show_num(); }; void P_example::show_num() { cout << num << "\n"; } int main() { P_example ob, *p; // Объявляем объект и указатель на него. ob.set_num(1); // Получаем прямой доступ к объекту ob. ob.show_num(); р = &ob; // Присваиваем указателю р адрес объекта ob. p->show_num(); // Получаем доступ к объекту ob с помощью указателя. return 0; } Обратите внимание на то, что адрес объекта ob получается путем использования оператора что соответствует получению адреса для переменных любого другого типа. Как вы знаете, при инкрементации или декрементации указателя он инкрементируется или декрементируется так, чтобы всегда указывать на следующий или предыдущий элемент базового типа. То же самое происходит и при инкрементации или декрементации указателя на объект: он будет указывать на следующий или предыдущий объект. Чтобы проиллюстрировать этот механизм, модифицируем предыдущую программу. Теперь вместо одного объекта ob объявим двухэлементный массив ob типа P_example. Обратите внимание на то, как инкрементируется и декрементируется указатель р для доступа к двум элементам этого массива. // Инкрементация и декрементация указателя на объект. #include using namespace std; class P_example { int num; public: void set_num(int val) {num = val;} void show_num(); }; void P_example::show_num() { cout << num << "\n"; } int main() { P_example ob[2], *p; ob[0].set_num(10); // прямой доступ к объектам ob[1].set_num(20); p = &ob[0]; // Получаем указатель на первый элемент. p->show_num(); // Отображаем значение элемента ob[0] с помощью указателя. p++; // Переходим к следующему объекту. p->show_num(); // Отображаем значение элемента ob[1] с помощью указателя. p--; // Возвращаемся к предыдущему объекту. p->show_num(); // Снова отображаем значение элемента ob[0]. return 0; } Вот как выглядят результаты выполнения этой программы. 10 20 10 Как будет показано ниже в этой книге, указатели на объекты играют главную роль в реализации одного из важнейших принципов C++: полиморфизма. Ссылки на объекты На объекты можно ссылаться таким же образом, как и на значения любого другого типа. Для этого не существует никаких специальных инструкций или ограничений. Но, как будет показано в следующей главе, использование ссылок на объекты позволяет справляться с некоторыми специфическими проблемами, которые могут встретиться при использовании классов. |