Int IntArray::get(unsigned index)

{if(index<size)return data[index];

else return 0;}

Void IntArray::put(unsigned index,int value)

{if(index<size)data[index]=value;}

IntArray::IntArray(void)

{data=new int[100];

size=100;

for(int i=0;i<size;i++)data[i]=0;}

IntArray IntArray(unsigned mySize)

{data=new int[mySize];

size=mySize;

for(int i=0;i<size;i++) data[i]=0;}

Main()

{IntArray myArray(200);

IntArray second(200);

second=myArray;

myArray.put(10,-50);

cout<<second.get(10);}

У результаті буде надруковане значення 10-го елемента масиву
– 50. Для даних об'єктів виділяється одна й та сама область пам'яті. При присвоюванні об'єктів не викликаються конструктори. Цю проблему можна легко розв'язати, якщо перевантажити оператор присвоювання.

Деструктори

Оскільки існують функції, які виконують дії з конструювання об'єк­та, то виникає необхідність в існуванні протилежних ним за дією функцій. Це особливо зрозуміло, якщо врахувати можливі дії конструкторів з виділення пам'яті. Такі функції в С++ існують і називаються деструкторами. Ім'я деструктора завжди починається із символу ~, за яким іде ідентифікатор імені класу: ~ім’я_класу(); Деструктор не може мати параметрів. У класі може бути оголошений тільки один деструктор. Він викликається автоматично при виході об'єкта з область видимості:

class char_s{

int size;

char*top;

char*s;

public:

char_s(int sz){top=s=new char[size-sz];}

~char_s(){delete s;}

void push(char c){*top++=c;}

char pop(){return*--top;}};

Коли char_stack виходить з області видимості, викликається деструктор:

Void f()

{char_s s1(100);

char_s s2(200);

s1.push('a');

s2.push(s1.pop());

char ch=s2.pop();

cout<<chr(ch)<<"\n";}

При виклику функції f() конструктор для char_s викликається двічі: для s1 – щоб виділити вектор зі 100 символів, для s2 – для виділення поля з 200 символів. При виході з f() ці два вектори звільняються автоматично.

Розглянемо ще один приклад на використання конструкторів і деструкторів. Нехай маємо клас Timer:

class Timer {

private:

long dt;

char*dts;

void DeleteDts(void);

publiс:

Timer();

Timer(int m,int d=-1,int y=-1,int hr=-1,int min=-1);

~Timer();//деструктор

void SetTime(int m=-1,int d=-1,int y=-1,\

int hr=-1,int min=-1);

const char*GetsTime(void);

Void ChangeTime(long nminutes)

{dt+=(nminutes*60);

DeleteDts();}

char*GetsTime(void)

{if(dts)return dts;

dts=strdup(ctime(&dt));

return dts;}};

Timer::Timer()

{dts=NULL;

Settime(-1,-1,-1,-1,-1);}

Timer::Timer(int m,int d,int y,int m,int min)

{dts=NULL;

SetTime(m,d,y,hr,min);}

Timer::~Timer()

{DeleteDts;}

Маємо фрагмент програми:

void f(void);

Main()

{f();

return 0;}

Void f(void)

{Timer today;

const char*sp;

sp=today.GetsTime();

cout<<"Second time:"<<sp;}

У прикладі функція main() викликає функцію f(), усередині якої оголошується автоматичний об'єкт today класу Timer, локальний в області видимості функції. Оскільки локальний автоматичний об'єкт створюється разом з викликом функції, у якій він оголошений, то С++ викликає для today конструктор Timer як частину коду, що виконується функцією при запуску. Подібна операція здійснюється завжди при виклику функції. Оскільки покажчик dts посилається на виділений блок пам'яті, то його потрібно звільнити при виході об’єкта з області видимості. Це й робить деструктор, який викликається автоматично. На відміну від конструктора, деструктор може бути викликаний явно: tuday.~Timer();