Тема: "Конструкторы и деструкторы".
Теоретическая часть
Конструктор класса - это функция-член класса, которая создаёт объекты данного класса, выделяя для них память и (или) инициируя их, однако для корректного определения класса часто необходимо иметь несколько конструкторов. Все они имеют одно и то же имя, совпадающее с именем класса, но отличаются числом и типом параметров. Одним из наиболее важных конструкторов является конструктор копирования. Он используется для копирования объектов и передачи их в качестве возвращаемого значения функции.
Класс MyStr, несмотря на возросшую эффективность, имеет 2 недостатка. Один из них обусловлен тем, что из-за неопределённости значения указателя pstr функции класса не будут работать корректно. Другой заключается в том, что память выделенная объектом при последнем обращении к ним освобождается только при выходе из программы.
Таким образом, необходимо выполнить дополнительные действия при создании объекта и при его удалении. Для этого в C++ они управляют процессом создания и удаления объектов и имеют необычный синтаксис:
1) Имя конструктора совпадает с именем класса и выглядит следующим образом: <имя класса>;
2) Имя деструктора тоже совпадает с именем класса, и выглядит он следующим образом: ~<имя класса>.

Объявим для класса MyStr конструктор и деструктор, тогда объявление класса будет выглядить следующим образом:

class MyStr
{
char*pstr; // указатель
int lstr;
public:
MyStr(); // конструктор
~MyStr(); // конструктор
char*getptr(void);
int length (void);
void copy (char*s);
void plus (char*s);
}
;

Конструктор и деструктор отличаются от обычных функций. Они не возвращают никакого типа (даже void) и при отсутствии параметров имеют пустой список вместо void.
В файл mystr.cpp добавим определение деструктораи конструктора класса MyStr.

MyStr: MyStr()
}
pstr = new char[1];
*pstr = `\0`;
lstr = 0;
}
MyStr::~MyStr()
{
delete [] pstr;
}

В определении конструктора отводится память для пустой строки (1 байт для 0 терминатора). Определить её содержимое (пустая строка) и длина (0).
Деструктор освобождает последний выделенный блок памяти.

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

Прототипы конструкторов для инициализации объектов
MyStr(); // без инициализации
MyStr(char*Wstr); // инициализация строки
MyStr(MyStr &Wstr); // инициализация другого объекта
В зависимости от контекста (типа и числа параметров конструктора), компилятор вызывает нужный вариант конструктора. Эта особенность называется перегрузкой конструктора.
Перегрузка широко используется в С++ не только для конструкторов и членов класса: практически любые функции могут быть перегружены. Перегрузка означает, что одним и тем же именем могут обозначаться разные варианты функций. Выбор нужного варианта выполняется в зависимости от числа и типа параметров.
Рассмотрим первые 2 конструкора. Первый определяет 1 байт для строки, инициирует пустую строку и определяет длину пустой строки равную 0.

MyStr::MyStr(char*Wstr)
{
// 2-й конструктор создаёт объект класса MyStr
// из обычной строки языка С++

pstr = new char [strlen (Wstr)+1];
strcpy (pstr, Wstr);
lstr = strlen(Wstr);
}

Определив эти конструкторы, можно инициализировать
объекты класса MyStr следующим образом:

MyStr str1; // без инициализации
MyStr str2("Привет!"); // инициализация строки

Конструктор по умолчанию.
Конструктор по умолчанию - это конструктор без параметров. Каждый класс должен иметь такой конструктор.
ВНИМАНИЕ! Если для класса явно не определено таких конструкторов, компилятор поддерживает скрытый конструктор - конструктор по умолчанию, который инициализирует данные-члены нулями. Но если для класса определен хотя бы один конструктор, конструктор по умолчанию исчезает.
Таким образом, в определение класса всегда следует включать конструктор без параметров, даже если он не выполняет никаких операций. После его явного определения он не может исчезнуть, даже если будет определен еще какой-либо конструктор.
Конструктор по умолчанию используется во многих ситуациях: при определении переменных без инициализации, объявлении массива без инициализации элементов, при задании оператора new без параметров. Если конструктор по умолчанию отсутствует, то во всех этих случаях возникает ошибка.

Конструктор копирования
Конструктор копирования MyStr (MyStr&). Он необходим для инициализации объекта с помощью другого объекта того же класса. Например:
MyStr str2("Привет!"); /*вызов MyStr(char*) */
MyStr str3(str2); /*инициализация str3, копии str2*/
Конструктором копирования называется конструктор, который используется для создания копии другого объекта того же класса. Этот конструктор очень важен, так как помимо объявления переменных он требуется в следующих случаях:
1) Когда объект класса как параметр функции определяется по значению:
void disp_str (MyStr Wstr;);
{
2) Когда объект класса является возвращаемым значением функции MyStr func (int Wn);
Т.к. эти ситуации возникают достаточно часто, компилятор поддерживает простейший скрытый конструктор копирования. Он просто копирует данные-члены одного объекта в данные-члены другого.
В некоторых случаях этого вполне достаточно, но не всегда. Например, для класса MyStr использование такого конструктора копирования может привести к печальным последствиям.
Допустим, для данных-членов объекта str3 выполнено копирование данных-членов объекта str2. Тогда указатели str3.pstr и str2.pstr указывают на один и тот же блок памяти. Таким образом, изменение содержимого строки одного объекта ведёт к изменению строки другого объекта. Но наиболее опасная ситуация возникает, когда один из объектов удаляется, и вместе с ним удаляется строка, адрес которой находился в поле pstr этого объекта. В этом случае поле pstr другого объекта является указателем на неопределённую область, что приводит к ошибке выполнения программы.

// пример 28
pstr1 = new MyStr;
pstr1->copy ("Привет!");
MyStr str2 (pstr1);
//...
delete pstr1; // удаление строки данных
puts (str2.getptr()); // Ошибка!

Следует отметить, что при удалении объекта информация в памяти, отведённой для него, изменяется не сразу, а только при следующем динамическом выделении памяти.
Ошибку при выполнении последней строки примера 28 может вызвать даже простое копирование в объект с указателем pstr1 нового значения строки с помощью функции copy:

pstr1 ->copy ("Новая строка");

В этом случае также происходит освобождение памяти и её новое выделение (см. также пример 27).

Таким образом, основная цель копирования должна состоять в том, чтобы при потере или удалении объекта-оригинала его копия продолжала полноценное существование и функционирование. Следовательно, конструктор копирования должен выполнять те же действия, что и конструктор. MyStr(char*): выделять новый блок памяти и лишь затем выполнять копирование строки данных и формирование длины строки.

Ссылки и конструктор копирования.
Сначала необходимо разобраться в том, что означает оператор ссылки (&) и как он используется при копировании.
Амперсанд используется для выполнения логической и побитовой операции И. Применение этого символа в различных операторах является примером перегрузки последних. При объявлении переменной наличие амперсанда означает, что эта переменная используется в качестве ссылки (дополнительного имени) другой переменной.

// пример 29
int x, &y = x; // y - ссылка на x
x = 0;
y =10; // означает, что х тоже равен 10

// Этот фрагмент эквивалентен следующему:

int x, *y;
y=&x; // y - ссылка на х
x = 0;
*y = 10; // означает, что х тоже равен 10

Внимательно сравнивая эти два фрагмента, можно отметить, что при определении переменной y в виде ссылки (&y) в первом варианте это выглядит как обычная целая переменная, и то, что фактически она является указателем на переменную x, скрыто синтаксисом С++.
Можно указывать амперсанд просто для создания дополнительного имени переменной, но наиболее важно его использование при вызове функций. Рассмотрим прототип конструктора класса MyStr:
MyStr (MyStr &wstr);
Этот конструктор имеет один параметр wstr, типом которого является ссылка на объект класса MyStr. Проще говоря, чтобы создать копию объекта, конструктор копирования получает ссылку на объект и через нее - доступ ко всем членам этого объекта.
ВНИМАНИЕ! Разница между передачей параметра как указателя передачи его по ссылке заключается в последовательности действий. При передаче указателя данные уже определены и для них определяется адрес (указатель). При передаче по ссылке сначала определяется адрес, а затем по этому адресу формируются данные.
С этой точки зрения всё, что нужно помнить об операторе ссылки - это то, что параметр берётся как значение, а не указатель, несмотря на то, что он передаётся по ссылке. Конструктор копирования в этом случае будет выглядеть так:

MyStr::MyStr(MyStr &wstr)
{
char *tmpstr;
int l;
tmpstr = wstr.getptr();
l = wstr.length();
pstr = new char [l+1];
strcpy (pstr, tmpstr);
lstr = l;
}
Этот конструктор во многом подобен конструктору MyStr(char*). Принципиальное отличие заключается в том, что конструктор должен сначала выделить строку и её длину во вспомогательных переменных, а затем уже с их помощью произвести копирование.
Заголовок конструктора может на первый взгляд показаться со странным из-за троекратного вхождения в него идентификатора MyStr, но каждая употребление MyStr в заголовке конструктора копирования играет свою роль: первое указывает на класс для которого определяется конструктор, второе - на имя конструктора, третье - на тип аргумента.
Защита параметра изменений.
Наконец, осталось уточнить одну небольшую деталь. Обычно передача параметра по ссылке употребляется в том случае, если нужно его изменять. Однако, в нашем случае изменение объекта, копия которого создаётся с помощью конструктора копирования, крайне нежелательно для таких случаев (C++ предлагется использование из ключевого слова const при объявлении параметров.
Итак, окончательный вариант конструктора копирования выглядит так:
MyStr::MyStr(const MyStr &wstr)
{
//...
//тело конструктора сохраняется
}

Теперь конструктор копирования не может изменить значение не одного из членов объекта wstr, т.к. любая попытка присвоить значение объекта wstr или любому из его данных-членов вызовет ошибку на этапе компиляции. Но существует ещё одно слабое место у этого конструктора: вызов функции getptr и length для объекта wstr. Как обеспечить неизменность параметра или его членов при вызове этих функций? Решением проблемы является объявление функций getptr и length функциями-константами.

char *MyStr::getptr(void)
const
{
return (pstr);
}
int MyStr::length(void)
const
{
return(lstr);
}

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

Примеры конструкторов.
Создадим несколько конструкторов для класса графических точек.

// пример 30
class GraphPoint
{
private:
int x, y, color;
public:
GraphPoint (); // конструктор по умолчанию
GraphPoint (int wx, int wy, int wcolor);
GraphPoint (const GraphPoint &wgp);
/*конструктор копирования*/
int getcolor(void);
void setnewcolor(int wcolor);
};

Класс GraphPoint значительно проще класса MyStr. Он не требует динамичного распределения и перераспределения памяти, а также её освобождения, поэтому конструктор по умолчанию может быть пустым. Он включается в определение класса только для того, чтобы избежать ошибок при неявном вызове конструктора этого типа. Таким образом, последний имеет вид:
GraphPoint::GraphPoint()
{
}
Следующий конструктор более интересен, он инициализирует на экране монитора графическую точку с координатами wx, wy, цвета wcolor.

GraphPoint::GraphPoint(int wx, int wy, int wcolor)
{
x = wx;
y = wy;
color = wcolor;
}
Наконец, конструктор копирования инициализирует объект, копируя в него данные-члены другого объекта этого класса. Объект, копия которого создаётся, передаётся конструктору в качестве параметра. Этот конструктор может отсутствовать в определении класса, так как он выполяется те же действия (почленное копирование), что и конструктор копирования поддерживаемый компилятором.

GraphPoint::GraphPoint(const GraphPoint &wgp)
{
x = wgp.x;
y = wgp.y;
color = wgp.color;
}
Далее приводятся примеры вызова каждого из описанных выше конструкторов:
GraphPoint gp1;
GraphPoint gp2(100, 50, YELLOW);
GraphPoint gp3 (gp2);

Вызов конструкторов и конверсия.
Итак, мы разобрали механизм вызова конструкторов во время работы программы. Что происходит при объявлении объектов с их одновременной инициализацией? Рассмотрим следующее объявление переменных.

// Пример 31
MyStr str1 ("Привет!");
MyStr str2 = str1;
MyStr str3 = "Привет!";

Понятно, что в первом объявлении вызывается конструктор MyStr (char*). Во втором объявлении также вызывается конструктор (конструктор копирования), и эта строка эквивалента показанной ниже строке не только по результату работы, но и по способу её выполнения:
MyStr str2 (str1);
При выполнении обеих строк вызывается один и тот же конструктор копирования MyStr (MyStr &).
В С++ присваивание и инициализация выполняются совершенно по-разному, несмотря на внешнее сходство операторов (=).
ВНИМАНИЕ! За исключением объявления переменных знак равенства всегда означает присваивание. При объявлении переменных он указывает на инициализацию, которая вызывает соответствующий типу переменной конструктор, а не оператор присваивания.
Программист может определить поведение оператора присваивания, но это не совсем тоже самое, что конструктор копирования. Иногда (но далеко не всегда) они действительно выполняют одни и те же действия. (Главным отличием является то, что конструктор копирования должен, как правило, сначала создать объект, а затем присваивать его членам начальное значения.) Аналогичным образом в последней строке примера 31вызывается конструктор MyStr (char*), и она эквивалентна 1-ой строке это же примера.
Существует ещё один случай, когда вызываются конструкторы и при преобразовании параметра какого-либо типа в класс. Однако, данная процедура выполяется только в том случае, если функция имеет ровно один параметр и существует конструктор класса из переменной этого типа.

// Пример 32
/*Прототип функции удаляющей пробелы из строки,
являющейся членом класса MyStr*/
MyStr Delete_Spaces (MyStr wstr);
// фрагмент вызывающей функции
MyStr str1;
str1 = Delete_Spaces ("123");

Последняя строка примера выполняет вызов конструктора MyStr (char*) для создания объекта класса MyStr и строки "123". Результирующий объект класса MyStr передаётся функции Delete_Spaces, и далее в нём удаляются пробелы.





Чтобы не видеть здесь видео-рекламу достаточно стать зарегистрированным пользователем.
Чтобы не видеть никакую рекламу на сайте, нужно стать VIP-пользователем.
Это можно сделать совершенно бесплатно. Читайте подробности тут.