Е. К. Пугачев Объектно-ориентированное программирование Под общей редакцией Ивановой Г. С. Рекомендовано Министерством общего и профессионального образования Российской Федерации в качестве учебник

Вид материала

Содержание

3.2.Конструкторы и деструкторы
Пример 3.35. Использование конструктора для инициализации полей класса
Пример 3.36. Использование переопределяемых конструкторов
Пример 3.37. Использование конструктора с аргументами по умолчанию
Пример 3.38. Использование конструктора со списком инициализации и неинициализирующего конструктора
Class1 (const Class1&)
Пример 3.39. Использование предполагаемого копирующего конструктора
Пример 3.40. Явное определение копирующего конструктора
Пример 3.41. Определение деструктора в классе

Подобный материал:

1 ... 13 14 15 16 17 18 19 20 ... 39

3.2.Конструкторы и деструкторы

Как упоминалось в предыдущем разделе, конструкторы и деструкторы представляют собой специальные методы класса, которые вызываются автоматически соответственно при создании и уничтожении объектов класса.

Конструкторы. По правилам С++ конструктор имеет тоже имя, что и класс, может не иметь аргументов, никогда не возвращает значения и определяет операции, которые необходимо выполнить при создании объекта. Обычно это выделение памяти под поля объекта в динамической области и инициализация полей, но могут выполняться и другие операции.

^ Пример 3.35. Использование конструктора для инициализации полей класса

Рассмотрим использование конструктора для инициализации полей класса, описанного в примере 3.2, изменив доступность поля strl. Конструктор инициализирует поля класса sstr и осуществляет действия, связанные с проверкой длины вводимой строки и коррекцией строки, в случае несоответствия.

#include

#include

#include

class sstr

{ private: char str1[40];

public: int x,y;

void print(void)

{ cout<<"содержимое общих полей: "<< endl;

cout<<"x= "<

cout<<" str1="<

sstr(int vx,int vy,char *vs) //конструктор класса sstr

{ int len=strlen(vs); // проверка правильности задания длины

if (len>=40) {strncpy(str1,vs,40);str1[40]='\0';} else strcpy(str1,vs);

x=vx;y=vy; }

};

void main()

{ clrscr();

//создание объекта класса sstr при наличии конструктора

sstr aa(200,150,"пример иcпользования конструктора ");

aa.print();

getch();

}

Как и любая другая компонентная функция, конструктор может быть переопределяемым, указывая соответствующие действия для различных списков параметров. Поэтому, класс может иметь несколько конструкторов, позволяющих использовать разные способы инициализации объектов.

^ Пример 3.36. Использование переопределяемых конструкторов

#include

#include

#include

class sstr

{ private: char str1[40];

public: int x,y;

void print(void)

{ cout<<" содержание полей : "<< endl;

cout<<" x= "<

sstr(char *vs) // конструктор, получающий значение поля str1

{int len=strlen(vs);

if (len>=40) {strncpy(str1,vs,40);str1[40]='\0';} else strcpy(str1,vs);

x=0; y=0; } // значения x и y задаются по умолчанию

sstr(char *vs,int vx) // конструктор, получающий значения str1 и x

{int len=strlen(vs);

if (len>=40) {strncpy(str1,vs,40);str1[40]='\0';} else strcpy(str1,vs);

x=vx; y=0; } // значение y задается по умолчанию

sstr(char *vs,int vx,int vy) // конструктор, получающий все значения

{ int len=strlen(vs);

if (len>=40) {strncpy(str1,vs,40);str1[40]='\0';} else strcpy(str1,vs);

x=vx;y=vy; }

};

void main()

{ clrscr();

sstr a0, a1("пример конструктора 1 c x и y по умолчанию");

sstr a2("пример конструктора 2 с y по умолчанию ",100);

sstr a3("пример иcпользования конструктора 3 ",200,150);

a0.print();

a1.print();

a2.print();

a3.print();

getch(); }

Кроме того, в самом конструкторе предусматривается возможность использования аргументов, заданных по умолчанию. В этом случае, вместо нескольких переопределяемых конструкторов можно использовать один. Вернемся к предыдущему примеру и заменим все переопределяемые конструкторы одним.

^ Пример 3.37. Использование конструктора с аргументами по умолчанию

#include

#include

#include

class sstr

{ private: char str1[40];

public:

int x,y;

void print(void)

{ cout<<" содержимое полей : "<< endl;

cout<<" x= "< /* тело конструктора с аргументами по умолчанию */

{ int len=strlen(vs);

if (len>=40) { strncpy(str1,vs,40); str1[40]='\0'; }

else strcpy(str1,vs);

x=vx;y=vy; }

void main()

{ clrscr();

sstr a0,a1(" x и y по умолчанию");

sstr a2(" y по умолчанию ",100);

sstr a3("определяет все поля",200,150);

a0.print(); // выводит: x=80 y=90 str1= строка по умолчанию

a1.print(); // выводит: x=80 y=90 str1= x и y по умолчанию

a2.print(); // выводит: x=100 y=90 str1= y по умолчанию

a3.print(); // выводит: x=200 y=150 str1= определяет все поля

getch(); }

В конструкторах может использоваться список инициализации, который отделяется от заголовка конструктора двоеточием и состоит из записей вида: <имя> (<список выражений>), где в качестве имени могут фигурировать:

имя поля данного класса,

имя объекта другого класса, включенного в данный класс,

имя базового класса.

Список выражений определяет значения, используемые для инициализации соответствующих объектов.

Чаще всего конструктор со списком инициализации применяется для задания начальных значений объектам, в которых используются фиксированные и ссылочные поля, а также поля, являющиеся объектами других, ранее определенных классов.

Иногда возникает необходимость создать объект, не инициализируя его поля. Такой объект называется неинициализированным и под него только резервируется память. Для создания подобного объекта следует предусмотреть неинициализирующий конструктор. У такого конструктора нет списка параметров и отсутствует тело («пустой» конструктор). В этом случае при объявлении объекта с использованием такого конструктора значение полей объекта не определено.

Ниже приводится пример использования конструктора со списком инициализации и неинициализирующего конструктора для объектных и фиксированных полей.

^ Пример 3.38. Использование конструктора со списком инициализации и неинициализирующего конструктора

#include

#include

class integ

{ int num;

public:

void print(void) { cout<<" num= "<

integ(int v):num(v){} // конструктор со списком инициализации

integ(void){} // неинициализирующий конструктор

};

class obinteg

{ integ onum; // поле объектного типа

public:

const int x,y,c; // поля фиксированного типа

void print(void) { onum.print();

cout<<" x="<

s1.print(); // выводит случайные числа

cout<<"данные неинициализируемого объекта obinteg s2"<

s2.print(); // выводит случайные числа

cout << " данные объекта класса integ: "<

aa.print(); // выводит заданные значения

cout << "данные объекта с объектным полем integ: "<

bb.print(); // выводит заданные значения

getch(); }

Не следует путать неинициализирующий конструктор с конструктором по умолчанию, так как последний иногда тоже не имеет списка параметров (пример 3.7), но в его теле задаются некоторые фиксированные значения полей. Если в определении класса уже описан конструктор по умолчанию (с параметрами или без таковых), то его можно использовать вместо неинициализирующего. При этом следует помнить, что поля объекта, образованного с помощью такого конструктора, будут определены. Использовать же в одном и том же классе оба вида конструкторов (конструктор по умолчанию и пустой конструктор) одновременно компилятор не позволяет.

Примечание. При использовании в программах массивов объектов некоторого класса, наличие неинициализирующего конструктора обязательно, так как сначала создается массив объектов, а только затем каждому объекту индивидуально присваиваются начальные значения.

В С++ при объявлении объектов допускается использование операции присваивания, в правой части которой указано имя ранее определенного объекта. Например, для объектов класса, описанного в предыдущем примере, можно выполнить инициализацию следующим образом:

integ A(20,30,50,6), C=A;

В этом случае для инициализации полей объекта С активизируется специальный копирующий конструктор.

Копирующим называется конструктор, который в списке параметров содержит параметр типа определяемого класса, например:

^ Class1 (const Class1&); или Class1(const Class1&,int=0);

Инициализация полей объекта при использовании копирующего конструктора выполняется методом копирования «поле за полем». При использовании данного метода последовательно выполняются конструкторы для всех полей инициализируемого объекта, причем в качестве параметров используются соответствующие значения полей объекта - параметра.

Копирующие конструкторы могут определяться в классе явно, а могут использоваться копирующие конструкторы, определенные по умолчанию. В последнем случае предполагается, что для каждого класса определен копирующий конструктор вида:

<имя класса> (const <имя класса>&),

за которым в зависимости от структуры класса может следовать список инициализации, включающий копирующие конструкторы базового класса и других полей. Этот конструктор в соответствии с предполагаемым описанием автоматически строится компилятором.

Примечание. Если для какого либо поля или базового класса явно определен копирующий конструктор без const, то и конструктор класса в целом неявно определяется без const.

^ Пример 3.39. Использование предполагаемого копирующего конструктора

#include

#include

#include

class child

{private:

char *name;

int age;

public:

void print(void)

{ cout<<" имя : "<

child(char *Name,int Age):name(Name),age(Age){}

};

void main()

{ clrscr();

child aa("Мария",6),bb("Евгений",5);

cout << " результаты работы программы: "<

aa.print(); // выводит: Мария и 6

bb.print(); // выводит: Евгений и 5

child dd=aa; /* предполагается использование копирующего конструктора */

dd.print(); // выводит: Мария и 6

getch();

}

В примере, приведенном выше, по умолчанию предполагается конструктор:

child(const child & obj):name(obj.name),age(obj.age){}

В результате поля объекта aa без изменения копируются в поля объекта dd.

Если же необходимо при копировании полей изменять их содержимое, следует явно определить в описании класса копирующий конструктор, предусмотрев действия по изменению значений всех или некоторых полей.

^ Пример 3.40. Явное определение копирующего конструктора

#include

#include

#include

class intpole

{ int cif;

public:

void print(void) { cout<<" cif ="<

intpole(int va) {cif=va;}

intpole(const intpole& ob1) // копирующий конструктор

{ cif= ob1.cif*3; }

};

class obpole

{ int num;

intpole intob; // объектное поле

public:

void print(void)

{ intob.print(); cout<<" num= "<

obpole(int vn,int va):num(vn),intob(va){}

};

void main()

{ clrscr();

obpole aa(10,40);

cout << " результаты работы программы: "<

aa.print(); // выводится 40 и 10

obpole bb=aa; // активизируется копирующий конструктор

bb.print(); // выводится 120 и 10

getch(); }

В приведенном примере для класса obpole предполагается копирующий конструктор по умолчанию:

obpole(const obpole &obj):num(obj.num) ,intob(obj.intob){ }

При инициализации объекта intob вызывается копирующий конструктор класса intpole, что приводит к инициализации соответствующего поля cif утроенным значением.

Кроме того, бывают случаи, когда поля объекта при копировании не изменяются, однако использование предполагаемого конструктора, автоматически создаваемого компилятором, может привести к непредсказуемым результатам.

Такая ситуация возникает, например, при передаче объекта в качестве параметра по значению некоторой функции. В этом случае, как известно, в памяти создается копия объекта, с которой должна работать функция. При создании копии должен вызываться копирующий конструктор, независимо от его наличия в описании класса. Автоматически генерируемый конструктор может не учесть некоторые особенности самого объекта и его полей. Особенно часто такие случаи происходят при работе с динамическими объектами и объектами, содержащими динамические поля (пример 3.30).

Деструкторы. Также как конструктор используется для создания объекта, для его уничтожения используется специальная функция - деструктор. Имя функции совпадает с именем класса, в начале которого стоит символ «~» - (префикс тильда). Деструктор определяет операции, которые необходимо выполнить при уничтожении объекта. Обычно деструктор используется для освобождения памяти, выделенной под объект данного класса конструктором.

Деструктор не возвращает значения, не имеет параметров и не наследуется в производных классах (раздел 3.3). Класс может иметь только один деструктор или не иметь ни одного. Так как деструктор - это функция, то он может быть виртуальным (раздел 3.4). Однако отсутствие параметров не позволяет перегружать деструктор.

Деструктор вызывается неявно, автоматически, как только объект класса уничтожается. Момент вызова определяется моделью памяти, выбранной для объекта (локальный, глобальный, внешний и т.д.). Если программа завершается с использованием функции exit, то вызывается деструктор только глобальных объектов. При завершении программы, использующей объекты некоторого класса, функцией abort деструктор не вызывается. Однако, в отличие от конструктора, деструктор можно вызвать и явно.

Если в классе не объявлены конструктор и деструктор, то некоторые компиляторы автоматически производят их построение. При этом конструктор используется для выделения памяти и размещения объекта после его описания, а деструктор - для корректного освобождения памяти после того, как имя объекта становится недействительным. В тех компиляторах, которые не производят автоматического построения конструкторов и деструкторов при их отсутствии, выдается диагностическое сообщение, требующее явного объявления этих компонент класса.

Примечание. Если объект содержал указатель на некоторую динамически выделенную область памяти, то по умолчанию эта память не освобождается.

^ Пример 3.41. Определение деструктора в классе

#include

#include

сlass din_string

{ char *str; // поле класса - строка

unsigned size;

public :

din_string(char *s,unsigned SIZE=100); // прототип конструктора

~din_string(); // прототип деструктора

void display(){cout <

};

din_string::din_string(char*s,unsigned SIZE) // конструктор

{ str = new char [size = SIZE]; strcpy(str,s);}

din_string::~din_string() // описание деструктора вне класса

{ delete [ ] str ; }

void main()

{ din_string A (“my example”);

char ss [] = “ve cjvhuter is very good”;

din_string *p = new din_string(ss,sizeof(ss));

p->display():

delete p; // уничножить объект – неявный вызов деструктора

A.display();} // деструктор A будет вызван после окончания программы

Blog

Содержание

3.2.Конструкторы и деструкторы