3.13 Дружні функції (1)

#include <iostream.h>

class A//клас A

{

int a,b;//закриті поля

public:

A(int ia, int ib):a(ia),b(ib){};

friend int sum(int pa,int pb);//оголошення дружньої функції (не члену класу A)

};

int sum(int pa, int pb)//визначення дружньої функції

{

A* obj=new A(pa,pb);

int s=obj->a+obj->b;//можливий доступ до закритих полів класу A

delete obj;

return s;

}

void main()

{

cout<<sum(2,3);//виклик дружньої функції

}

3.14 Дружні функції (2)

#include <iostream.h>

class A//клас A

{

int a,b;//закриті поля

public:

A(int ia, int ib):a(ia),b(ib){};

friend int sum(A);//оголошення дружньої функції (не члену класу A)

};

int sum(A pobj)//визначення дружньої функції

{

return pobj.a+pobj.b;//можливий доступ до закритих полів класу A

}

void main()

{

A obj(2,3);//створити об’єкт obj

cout<<sum(obj);//викликати дружню функцію з аргументом obj

}

3.15 Успадкування

#include <iostream.h>

class A//базовий клас A

{

protected://захищені члени

int a;//поле

public://відкриті члени

A(int ia):a(ia){};//конструктор

};

//клас B, він успадковує клас A

class B:public A

{

//закриті члени

int b;//поле

public://відкриті члени

B(int ia, int ib):A(ia),b(ib){};//конструктор

int sum(){return a+b;}//метод

};

void main()

{

B obj(2,3);//створити об’єкт obj класу B, ініціалізувати a=2,b=3

cout<<obj.sum();

}

3.16 Статичний поліморфізм, перевантаження методів

#include <iostream.h>

class A//клас A

{

int c;

double cd;

public:

//перевантажені методи sum

int sum(int a, int b);

double sum(double ad, double bd);

void print()

{cout<<c<<" "<<cd<<endl;}

};

//визначення перевантаженого методу sum,

//який отримує і повертає дані цілого типу

int A::sum(int a, int b)

{return c=a+b;}

//визначення перевантаженого методу sum,

//який отримує і повертає дані дійсного типу

double A::sum(double ad, double bd)

{return cd=ad+bd;}

void main()

{

A obj;

cout<<obj.sum(2,3)<<endl;//виклик методу sum(int a, int b)

cout<<obj.sum(2.1,3.05)<<endl;//виклик методу sum(double ad, double bd)

obj.print();

}

3.17 Перевантаження операторів

#include <iostream.h>

class A//клас A

{

int a;

public:

A(int inita):a(inita){};//конструктор

A(A &obj){a=obj.a;}//конструктор копіювання

//перевантажена операторна функція-член operator+,

//яка отримує посилання і повертає об’єкт класу A

A operator+(const A& obj)

{

A obj_sum(0);//створити об’єкт класу A

//присвоїти результату суму поля a та поля a об’єкта obj (аргументу)

obj_sum.a=a+obj.a;

return obj_sum;//повернути результат obj_sum

}

void print(){cout<<a;}

};

void main()

{

A obj1(2),obj2(3),obj3(0);//створити об’єкти класу A

obj3=obj1+obj2;//застосування перевантаженого оператора +

//або obj3=obj1.operator+(obj2)

obj3.print();

}

3.18 Динамічний поліморфізм, віртуальні функції (1)

#include <iostream.h>

class A//базовий клас A

{

protected:

int a;

public:

A(int ia):a(ia){};

//віртуальна функція

virtual void print() //спробуйте без слова virtual

{cout<<a<<endl;}

};

class B: public A//клас B, він успадковує клас A

{

protected:

int b;

public:

B(int ia, int ib):A(ia),b(ib){};

void print()//віртуальна функція

{cout<<a<<" "<<b<<endl;}

};

class C: public B//клас C, він успадковує клас B

{

protected:

int c;

public:

C(int ia,int ib, int ic):B(ia,ib),c(ic){};

void print()//віртуальна функція

{cout<<a<<" "<<b<<" "<<c<<endl;}

};

void main()

{

A obj1(1); obj1.print();

B obj2(2,3); obj2.print();

C obj3(4,5,6); obj3.print(); //віртуальність не потрібна

A* pobj;

pobj=&obj1; pobj->print();

pobj=&obj2; pobj->print();

pobj=&obj3; pobj->print(); //необхідна віртуальність

A* pobj1=new A(1); pobj1->print();

A* pobj2=new B(2,3); pobj2->print();

A* pobj3=new C(4,5,6); pobj3->print(); //необхідна віртуальність

}