23.Конструкторы и деструкторы. Параметризованные конструкторы. Встраиваемые функции в объявлении класса.
Конструкторы и деструкторы
Конструктор — это функция, которая вызывается при создании объекта.
Как правило, некоторую часть объекта, прежде чем его можно будет использовать, необходимо инициализировать. Например, рассмотрим класс 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(){
sloe = rloc = 0;
cout << "Очередь инициализирована.\n"; }
// Определение деструктора,
queue::~queue() {
cout << "Очередь разрушена.\n"; }
Вот как выглядит новая версия программы реализации очереди, в которой демонстрируется использование конструктора и деструктора.
//274
// Демонстрация использования конструктора и деструктора,
#include <conio.h>
#include <iostream.h>
// Определение класса 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 () {clrscr();
queue a, b; // Создание двух объектов класса queue.
a.qput(10) ; b.qput(19);
a.qput(20); b.qput (1);
cout << a.qget()<<" ";
cout << a.qget()<<" ";
cout << b.qget()<<" ";
cout << b.qget()<<"\n";
getch(); 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 a = queue(101);
В этом объявлении создается очередь с именем а, которой передается значение (идентификационный номер) 101. Но эта форма (в таком контексте) используется редко, поскольку второй способ имеет более короткую запись и удобнее для использования. Во втором способе аргумент должен следовать за именем объекта и заключаться в круглые скобки. Например, следующая инструкция эквивалентна предыдущему объявлению.
queue a(101) ;
Это самый распространенный способ объявления параметризованных объектов. Опираясь на этот метод, приведем общий формат передачи аргументов конструкторам.
тип_класса имя_переменной(список_аргументов);
Здесь элемент список_аргументов представляет собой список разделенных запятыми аргументов, передаваемых конструктору
На заметку. Формально между двумя приведенными выше формами инициализации существует небольшое различие, которое вы поймете при дальнейшем чтении этой книги. Но это различие не влияет на результаты выполнения программ, представленных в этой главе.
В следующей версии программы организации очереди демонстрируется использование параметризованного конструктора.
//277
// Использование параметризованного конструктора.
#include <conio.h>
#include <iostream.h>
// Определение класса 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 () {clrscr();
queue a(1), b(2); // Создание двух объектов класса queue.
a.qput (10);
b.qput (19);
a.qput(20);
b.qput(1);
cout << a.qget()<<" ";
cout<< a.qget()<<" ";
cout << b.qget()<<" ";
cout << b.qget()<<"\n";
getch(); return 0; }
При выполнении эта версия программы генерирует такие результаты:
Очередь 1 инициализирована.
Очередь 2 инициализирована.
10 20
19 1
Очередь 2 разрушена.
Очередь 1 разрушена.
Как видно из кода функции main (), очереди, связанной с именем а, присваивается идентификационный номер 1, а очереди, связанной с именем b, — идентификационный номер 2.
Несмотря на то что в примере с использованием класса queue при создании объекта передается только один аргумент, в общем случае возможна передача двух аргументов и более. В следующем примере объектам типа widget передается два значения.
//278
//два параметра передаются конструктору
#include <conio.h>
#include <iostream.h>
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() { clrscr();
widget x(10, 20), y(0, 0);
x.put_widget(); y.put_widget();
getch(); return 0; }
Важно! В отличие от конструкторов, деструкторы не могут иметь параметров. Причину понять нетрудно: не существует средств передачи аргументов объекту, который разрушается. Если же у вас возникнет та редкая ситуация, когда при вызове деструктора вашему объекту необходимо получить доступ к некоторым данным, определяемым только во время выполнения программы, создайте для этой цели специальную переменную. Затем непосредственно перед разрушением объекта установите эту переменную равной нужному значению.
При выполнении эта программа отображает следующие результаты.
10 20
0 0
Альтернативный вариант инициализации объекта
Если конструктор принимает только один параметр, можно использовать альтернативный способ инициализации членов объекта. Рассмотрим следующую программу.
//279
//альтернативный вариант инициализации объекта
#include <conio.h>
#include <iostream.h>
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 () { clrscr();
myclass ob = 4; // вызов функции myclass(4)
cout << ob.get_a();
getch(); return 0; }
Здесь конструктор для объектов класса myclass принимает только один параметр. Обратите внимание на то, как в функции main() объявляется объект ob. Для этого используется такой формат объявления:
myclass ob = 4;
В этой форме инициализации объекта число 4 автоматически передается параметру х при вызове конструктора myclass (). Другими словами, эта инструкция объявления обрабатывается компилятором так, как если бы она была записана следующим образом.
myclass ob = myclass(4);
В
общем случае, если у вас есть конструктор,
который принимает только один аргумент,
для инициализации объекта вы можете
использовать либо вариант ob
(х), либо 
вариант
ob
= х. Дело в том, что при создании конструктора
с одним аргументом неявно создается
преобразование из типа этого аргумента
в тип этого класса.
Помните, что показанный здесь альтернативный способ инициализации объектов применяется только к конструкторам, которые имеют только один параметр.