ООП / учебное_пособие

{ cout<<"вид операции: 1 − создать дерево"<<endl;

{case 1: t.sozd(); break;

case 2: t.see(t.root()); break; case 6: return;

}

return 0;

}

}

При небольшой модификации в функции main() можно создать несколько объектов класса tree и, например, используя указатель на объект класса tree, вызывать методы класса для работы с каждым из созданных объектов (бинарных деревьев). Это преобразование предлагается выполнить самостоятельно.

3.3. Конструктор копирования

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

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

имя_класса (const имя_класса & );

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

#include <iostream> using namespace std; #include <stdlib.h> #include <locale.h>

31

class cls

{char *str; int dl;

// . . . другие данные класса

}; cls::cls ()

{cout<<" работает конструктор без параметров"<<endl; dl=0;

str=NULL;

}

cls::cls (char *st)

{ cout<<" работает конструктор c параметром"<<endl;

cls::~cls()

{delete [] str;

cout<<" работает деструктор"<<endl;

}

// Пример функции, использующей конструктор копирования

// код функции

cout<<" выполняется функция "<<endl; return obj5;

}

int main()

32

{ cls obj1(" символьная строка "), obj2;

cls obj3=obj1; // пример явного вызова копирующего конструктора setlocale (LC_ALL, "RUS");

//. . .

obj2=fun(obj3);

//. . .

return 0;

}

В приведенном выше примере, в строке: cls obj3=obj1;

демонстрируется способ явного вызова конструктора копирования объекта obj1 в объект obj3. при вызове функции fun(obj3) выполняется копирование объекта obj3 в локальный объект obj4 функции fun.

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

Необходимо отметить, что для правильной работы инструкции в строке obj2=fun(obj3), требуется перегрузить операцию = (равно). Это будет рассмотрено несколько позже.

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

3.4.Конструктор explicit

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

#include <iostream> using namespace std; #include <locale.h>

public:

array(int = 1); // объявление конструктора с параметром по умолчанию

~array();

friend void print(const array&);

33

};

array::array(int kl) : size(kl)

{ cout<<"работает конструктор"<<endl;

ms=new int[size]; // выделение памяти для массива for(int i=0; i<size; i++) ms[i]=0; // инициализация

}

array::~array()

{ cout<<"работает деструктор"<<endl; delete [] ms;

}

void print(const array& obj)

{ cout<<"выводится массив размерностью"<<obj.size<<endl; for(int i=0; i<obj.size; i++)

cout<<obj.ms[i];

cout<<endl;

}

int main()

{array obj(10);

setlocale (LC_ALL, "RUS");

}

Врезультате выполнения программы получим: работает конструктор выводится массив размерностью 10

0 0 0 0 0 0 0 0 0 0

работает конструктор выводится массив размерностью 5

0 0 0 0 0

работает деструктор работает деструктор

Вданном примере в инструкции:

array obj(10);

определяется объект obj и для его создания (и инициализации) вызывается конструктор array(int). Далее в инструкции:

print(obj); // вывод содержимого объекта obj

выводится содержимое объекта obj, используя friend-функцию print(). При выполнении инструкции:

print(5); // преобразование 5 в array и вывод

компилятором не находится функция print(int) и выполняется проверка на наличие в классе array конструктора, способного выполнить преобразование в

34

объект класса array. Так как в классе array имеется конструктор array(int), а точнее, просто конструктор с одним параметром, то такое преобразование возможно (создается временный объект, содержащий массив из пяти чисел).

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

explicit array(int = 1);

не может быть использован для неявного преобразования. В этом случае компилятором (в частности Microosft C++) будет выдано сообщение об ошибке:

Compiling...

error C2664: 'print' : cannot convert parameter 1 from 'const int' to 'const class array &' Reason: cannot convert from 'const int' to 'const class array'

No constructor could take the source type, or constructor overload resolution was ambiguous

Если необходимо при использовании explicit-конструктора все же создать массив и передать его в функцию print, то надо использовать инструкцию

print(array(5));

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

array::array(int n,int m)

{this->n=n;

ms=new int[this->n];

35

for(int i=0;i<this->n;i++) ms[i]=m;

}

array::array(array_size _size)

{n=_size.size(); ms=new int[n];

}

array::~array(){ delete [] ms;}

int main()

{ array obj(1);

. . .

return 0;

};

Компилятор для объекта obj генерирует вызов конструктора array(int). Но такого конструктора не существует. Компиляторы могут преобразовать аргумент типа int во временный объект array_size, поскольку в классе array_size имеется конструктор с одним параметром. Это обеспечивает успешное создание объекта.

3.5. Указатель this

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

my_class ob1,ob2;

Вызовы компонент-функций имеют вид ob1.fun_1();

ob2.fun_2();

Пусть в обеих функциях содержится инструкция cout << str;

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

my_class *const this;

Таким образом, при объявлении объектов ob1 и ob2 создаются два thisуказателя на эти объекты. Следовательно, любая функция, являющаяся компонентой некоторого объекта, при вызове получает this-указатель на этот объект. И приведенная выше инструкция в функции воспринимается как

36

cout << this->str;

Однако эта форма записи избыточна. С другой стороны, явное использование указателя this эффективно при решении некоторых задач.

Рассмотрим пример использования this-указателя на примере упорядочивания чисел в массиве.

#include<iostream> using namespace std; #include<stdio.h>

{for(int i=0;i<2;i++) for(int j=i;j<3;j++)

if (a[i]>a[j]) {a[i]=a[i]+a[j]; a[j]=a[i]-a[j]; a[i]=a[i]-a[j];}

Вызов компонент-функций для каждого из созданных объектов осуществляется

o1.inpt()->srt().out;

Приведенная инструкция интерпретируется следующим образом:

37

сначала вызывается функция inpt для ввода информации в массив данных объекта о1;

функция inpt возвращает адрес памяти, где расположен объект о1;

далее вызывается функция сортировки информации в массиве, возвращающая содержимое объекта о1;

после этого вызывается функция вывода информации.

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

#include<iostream.h>

#include<string.h>

~B(){delete [] this->ss;}

char *f_this(void){return this->ss;}

};

void A::pos_str(char *s)

{char *dd; int i,ii;

dd=new char[strlen(this->s)+strlen(s)+2]; //память для перезаписи 2 строк

cout << this->s << endl;

}

void main(void)

{A a1("aa bcc dd ee"); B b1("bd"); a1.pos_str(b1.f_this());

}

В результате выполнения программы получим aa bcc dd ee bd

Отметим основные правила использования this-указателей:

- каждому объявляемому объекту соответствует свой скрытый this-указа-

тель;

- this-указатель может быть использован только для нестатической функ-

ции;

-this указывает на начало своего объекта в памяти;

-this не надо дополнительно объявлять;

-this передается как скрытый аргумент во все нестатические (не имеющие спецификатора static) компоненты-функции своего объекта;

-указатель this − локальная переменная и недоступна за пределами объ-

екта;

-обращаться к скрытому указателю можно this или *this.

3.6. Встроенные функции (спецификатор inline)

В ряде случаев в качестве компонент класса используются достаточно простые функции. Вызов функции означает переход к памяти, в которой расположен выполняемый код функции. Команда перехода занимает память и требует времени на ее выполнение, что иногда существенно превышает затраты памяти на хранение кода самой функции. Для таких функций целесообразно поместить код функции вместо выполнения перехода к функции. В этом случае при выполнении функции (обращении к ней) выполняется сразу ее код. Функции с такими свойствами являются встроенными. Иначе говоря, если описание компоненты функции включается в класс, то такая функция называется встроенной. Например:

class stroka

{ char str[100]; public:

…….. int size()

{for(int i=0; *(str+i); i++); return i;

}

39

};

В описанном примере функция size() – встроенная. Если функция, объявленная в классе, а описанная за его пределами, должна быть встроенной, то она описывается со спецификатором inline:

class stroka

{ char str[100]; public:

…….. int size();

};

inline int stroka ::size()

{for(int i=0; str[i]; i++); return i;

}

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

3.7. Организация внешнего доступа к локальным компонентам класса (спецификатор friend)

Мы уже познакомились с основным правилом ООП – данные (внутренние переменные) объекта защищены от воздействий извне и доступ к ним можно получить только с помощью функций (методов) объекта. Но бывают такие случаи, когда нам необходимо организовать доступ к данным объекта, не используя его интерфейс (функции). Конечно, можно добавить новую publicфункцию к классу для получения прямого доступа к внутренним переменным. Однако в большинстве случаев интерфейс объекта реализует определенные операции, и новая функция может оказаться излишней. В то же время иногда возникает необходимость организации прямого доступа к внутренним (локальным) данным двух разных объектов из одной функции. При этом в С++ одна функция не может быть компонентой двух различных классов.

Для реализации этого в С++ введен спецификатор friend. Если некоторая функция определена как friend-функция для некоторого класса, то она:

-не является компонентой-функцией этого класса;

-имеет доступ ко всем компонентам этого класса (private, public и protected).

Ниже рассматривается пример, когда внешняя функция получает доступ

квнутренним данным класса.

#include <iostream> using namespace std; class kls

{ int i,j;

40