Використання специфікаторів доступу класу

Class line

{

publі*:

int x1, y1, x2 , y2 ;

line(int _x1,   int _y1,  int    x2,   inty2);

void show();

void move(int x,int y) ;

line  ()   ;

};

Void main ()

{

// створюється об'єкт s класу line

lines(12,43,33,43);

int localx, localy;

localx=s.x1; //доступ до елементу-даних  x1

localy=s.y1; //доступ до елементу-даних  y1

s.show();     //доступ до елемента-функції show();

}

 

Отже, доступ до членів класу  здійснюється за допомогою оператору "крапка"(.). Цей оператор повідомляє про те,що потрібно забезпечити доступ до елементу класу, змінна якого являє  собою окремий його екземпляр.

Повідомлення

В деяких об’єктно-орієнтованих мовах програмування виклики  методів об’єктів називають повідомленнями. Так, наприклад, викли*

s1.showdata();

можна розглядати як посилання  повідомлення об’єкту s1 з вказівкою  вивести на екран свої дані. Термін повідомлення не входить до числа  формальних термінів мови С++, але його корисно пам’ятати при подальшому обговоренні. Представлення виклику  методів у вигляді повідомлень  підкреслює незалежність об’єктів як самостійних одиниць, взаємодія  з якими здійснюється шляхом звертання  до їх методів.

 

6. КЛАС ЯК ТИП ДАНИХ

 

Розглянемо приклад, що демонструє використання об’єктів С++ в якості змінних типу, визначеного користувачем. Об’єкти будуть представляти відстані, виражені в англійській системі  мір.  Далі приведений ліс**нг програми (програм*)

#include <iostream.h>

#include <conio.h>

#include <bios.h>

class Distance

{ private:

int feet;

float inches;

public:

void setdist(int f1, float in)

{feet=f1; inches=in;};

void getdist()

{cout <<”\n Введіть число футів “; cin >>feet;

cout << “Дюймів “; cin>>inches;

}

void showdist()

{cout <<feet << “\’ “<< inches <<”\’**;}

};

int main()

{ Distance dist1,dist2; //дві довжини

clrscr();

dist1.setdist(11,6.25); //встановлення  значень для d1

dist2.getdist(); //ввід значень  для d2

cout <<”\ndist1=”;dist1.showdist();

cout << “\ndist2=”;dist2.showdist();

cout <<endl;

bioskey(0);

return 0;

}

Програма 

В цій програмі кла* Distance містить два поля: feet та inches та три методи: setdist, getdist, showdist. Значення полів можуть вводитися двома способами: через метод setdist та getdist.

 

7. КОНСТРУКТОРИ.

 

С++ дає можливість створити метод, що буде автоматично викликатися  для ініціалізації об'єкта даного типу при його створенні. Такий метод  називається конструкторо*.

Конструктор визначає, як буде створюватися новий об'єкт, коли це необхідно, може розподілити під  нього пам'ять і ініціалізувати її. Він може містити в собі код для розподілу пам'яті, присвоювання значень елементам, перетворення з одного типу в інший і т.д.

Конструктори в мові С++ мають імена, що збігаються з ім'ям класу. Конструктор може бути визначений користувачем, або компілятор сам  згенеру* конструктор за замовчуванням. Компілятор сам автоматично викликає відповідний конструктор там, де оголошується новий об'єкт класу. Конструктор не повертає ніяке значення, і при описі конструктора не використається ключове слово void.

Наприкла*:

Class cdemo

{ long count;

public:

cdemo();

void func();

};

// визначення конструктора  по замовчуванню 

cdemo::cdemo()

{

Printf ("Створення об'єкту cdemo");

count=0;  // ініціалізація  внутрішніх даних

}

Конструктор присвоює змінній  count початкове значення та видає на екран повідомлення про створення об'єкту клас cdemo. При створенні об’єкту вказаного типу функція-конструктор буде викликана автоматично. Це найпримітивніший конструктор.

Існують три типи конструкторів:

• за умовчання*,
• з параметрами,
• копіювання.

Оголошення та використання конструкторів може проходити за одною із наступних схе*:

• за умовчання*

Конструктор, що оголошується без аргументів по замовчуванн*.

Якщо він не визначений в описі класу, компілятор створює  його по замовчуванню (на практиці він  просто виділяє пам'ять при створенні  об'єкту свого класу). Як приклад, можна  розглянути наступн*:

Classs phere

{

public:

float r; float x,y,z;

sphere()  

{

x=1.0;   y=2.0;   z=3.0;   r=4;

}

};

 

• з параметрами

Більшість конструкторів  використовуються з параметрами.

Адже не дуже вдалим буде рішення, після того, як створивши  об’єкт потім ще додатково викликати  окрему функцію ініціалізації для  збереження в ньому певних даних.

Наведений нижче код допомож* ініціалізувати об'єкт саме у момент його створення. Нехай є таке оголошення конструктора у попередньо відомому класі sphere:

Sphere (float xcoord, float ycoord, float zcoord, float radius);

Тоді визначення конструктора має бути наступним:

// визначення конструктор*

sphere::sphere(float xcoord, float ycoord, float zcoord, float radius)

{

x=xcoord; y=ycoord; z=zcoord; r=radius;

}

Враховуючи таке оголошення конструктора, необхідно при створенні  об'єкту передати йому аргументи, що робить ініціалізацію екземпляру схожим на виклик функції:

sphere s(1.0,   2.0,   3.0,   4.0);

Як бачимо у такому разі, змінна визначається т* ініціалізуютьс* в одному рядку. Для найбільш гнучкої ситуації іноді є сенс оголосити конструктори з різним типом та кількістю аргументів, що дозволяє будувати більш зрозумілі та пристосовані до користувача класи. Тобто конструктори, як і звичайні функції-елементи, можна перевантажувати. Компілятор, проаналізувавши аргументи при створенні об'єкту, спроможний автоматично визначити, який з конструкторів викликати. При цьому використовуються відомі правила відповідності аргументів при перевантаженні функцій.

Крім того, в C++ зустрічаються  дві форми ініціалізації з  параметрами:

1. Ініціалізація у тілі конструктор*::

Class two

{ int x,y;

public:

two(int x1, int y1) 

{

x=x1;    // присвоєння  у тілі конструктор*

y=y1;

};

 

2. Ініціалізація списком після заголовку визначення функції:

Class one

{ int х,у;

public:

one (int x1, int y1):x(x1),y(y1)

{

}

};

 

Обидві форми абсолютно  рівнозначні, друга, правда, зустрічається  дещо  рідше.

• копіювання.

У цьому випадку мається  на увазі отримання копій вже  існуючого об’єкту, що у свою чергу, потребує особливого конструктора, що носить назву ініціалізатора копії, або конструктор копіювання.

Конструктор копіювання - це спеціальний вид конструктора, який отримує в якості єдиного параметра  вказівник на об’єкт цього ж класу.

example::example(example & referance)

{count = referance.count;

}

void main()

{ example object (5) ;                   //використання конструктора для int              

    example

 objectl=object;                            //використання конструктора копіюванн*

        //відбувається копіювання між objectl та  

   object

}

Конструктори копіювання надзвичайно важливі у випадках, коли потрібно створити копію об'єкту класу. Без них компілятор не спроможни* виконати копіювання - все повністю залежить від існуючого конструктора. Копіювання об'єктів відбувається при передачі об'єктів за значенням у функцію або навпаки.

Розглянемо приклад, що демонструє передачу об'єктів за значенням:

// функція отримує змінну  класу за значенням

Void func(sorceobj)

{

obj.classfunc();  // виклик компонентної функції класу sorce

}

Void main(void)

{  sorceobj(10) ; // автоматична змінн*

func(obj);     //передача функції об'єкта за значенням

}

При активації func (obj) компілятор використовує конструктор копіювання для розміщення в стеку копії об'єкту в якості аргументу. Передача за значенням зовсім ще не означатиме, що функція обов'язково отримає точну побайтов* копію об’єкту. Адже те, що отримає функція, повністю залежить віл того, що підготовлено конструктором копіювання. Подібна до цього ситуація і тоді, коли об'єкт повертається за значенням. (Зауваження: деякі компілятори можуть працювати інакше).

Конструктор копіювання за замовчуванням

Ми розглянули два способи  ініціалізації об’єктів. Конструктор  без аргументів мож* ініціалізувати поля об’єкту константними значеннями, а конструктор, що має хоч один аргумент, може ініціалізувати поля значеннями, переданими йому як аргументи. Розглянемо третій спосіб ініціалізації об’єкту, що використовує значення полів вже існуючого об’єкта. Для цього не потрібно самим створювати спеціальний конструктор, оскільки такий конструктор надається компілятором для кожного існуючого класу і називається копіюючи* конструктором за замовчуванням. Копіюючи* конструктор має єдиний аргумент, який є об’єктом такого ж класу, що й конструктор.

Програма демонструє використанн* копіюючого конструктора за замовчуванням.

#include<iostream.h>

#include<conio.h>

#include<bios.h>

Class Distance

{private:

Int feet;

Float inches;

public:

Distance():feet(0),inches(0.0) //Конструктор без аргументі*

{cout<<”c1”<<endl; }

//Конструктор з 2 аргументами

Distance(int ft,float in):feet(ft),inches(in)

{cout<<”c2”<<endl;

}

Void getdist()

{cout<<”\n Введіть число футів “; cin>> feet;

cout<< “Дюймів “; cin>>inches;

}

Void showdist()

{cout<<feet<< “\’ “<<inches<<”\’**;}

};

Int main()

{  clrscr();

Distance dist1(11,6.25); //конструктор з 2 аргументами

Distance dist2(dist1); //два конструктори з одним аргументо*

Distance dist3=dist1;

cout<<”\ndist1=”;dist1.showdist();

cout<< “\ndist2=”;dist2.showdist();

cout<< “\ndist3=”;dist3.showdist();

cout<<endl;

bioskey(0);

return 0;

}

 

Ми ініціалізували об’єкт dist1 за допомогою конструктора з двома аргументами. Потім ми визначаємо ще два об’єкти класу Distance з іменами dist2 і dist3, вони обидва ініціалізуютьс* значенням об’єкту dist1. В обох випадках був викликаний копіюючи* конструктор за замовчуванням. Об’єкт dist2 ініціалізовани* за допомогою оператора:

Distance dist2(dist1);

Ді* копіюючого конструктора за замовчуванням зводиться до копіювання значень полів об’єкту dist1 у відповідні поля об’єкту dist2. Як це не дивно, але ідентичні дії для пари об’єктів dist1 і dist3 виконуються за допомогою операторів:

Distance dist3=dist1;

Можна подумати, що даний  оператор виконує операцію присвоювання, але насправді це не так. Тут, як і  в попередньому випадку викликається конструктор копіювання за замовчуванням. Обидва оператори виконують одинакові  дії і рівноправні у використанні. Можемо переконатися в цьому, запустивши програму 11.6 на виконання.

Перезавантажен* конструктор*

Було б зручно здійснювати  ініціалізацію змінних тип* Distance в момент їх створення. Щоб це зробити, викличемо конструктор так:

Distance(int ft,float in):feet(ft),inches(in)

{ }

Ми ініціалізуєм* поля feet та inches тими значеннями, які передаються конструктору в якості аргументів.

Разом з тим, ми хочемо зберегти можливість визначати змінні тип* Distance без ініціалізації, як ми це робили в програмі 11.3.

Distance dist1,dist2;

В програмі 11.3 не було конструктора, але визначення працювали без  помилок. Чому так відбувалося? Це пояснюється  тим, що компілятор автоматично вбудовує в програму конструктор без параметрів, який і створює змінні класу, хоча явного визначення конструктора ми не робили. Такий конструктор без  параметрів називається конструктором  за замовчуванням.

Часто нам хотілося б, щоб  початкові значення полів об’єкта  присвоювалися також і в конструкторі без параметрів. Якщо покласти цю функцію  на конструктор за замовчуванням, то ми не зможемо дізнатися, якими значеннями бул* ініціалізовані поля. Якщо для нас істотно, якими значеннями будуть ініціалізуватися  поля об’єктів класу, то слід явно визначити конструктор. В програмі 11.5 ми вчинили це так:

Distance():feet(0),inches(0.0) //конструктор без аргументі*

{ }

Члени класу ініціалізуютьс* константними значеннями, в даному випадку цілим значенням 0 для поля feet і дійсним значенням 0.0 для поля inches. Отже, ми можемо використовувати об’єкти, ініціалізовані за допомогою конструктора без параметрів, будучи певними в тому, що поля об’єктів мають нульове, а не довільне значення.