Лекция 6 Наследование

1. Наследование

Васильева Лидия Николаевна
доцент кафедры автоматики и управления
в технических системах

2. Наследование как принцип ООП

3. Основная форма наследования

В C++ наследование используется для
поддержки иерархии классов и для
поддержки полиморфизма.
Основная форма наследования:
class имя_производного: сп_доступа
имя_базового {
// определение производного класса
};
сп_доступа может быть: public, private
или protected.

4. Спецификаторы public, private

При наследовании со спецификатором public,
все открытые члены базового класса остаются
открытыми в производном.
Если спецификатор private, то все открытые
члены базового класса становятся закрытыми в
производном классе.
При любом наследовании все закрытые члены
базового класса остаются закрытыми в
производном.

5. Спецификатор protected в определении класса

Спецификатор
доступа
protected
(защищенный).
Применяется, если необходимо, чтобы члены базового
класса, оставаясь закрытыми, были доступны для
производного класса. Вне производного класса protected
эквивалентен private.
Объявление элементов класса
class имя класса {
private:
// закрытые члены
protected:
// защищенные члены класса
public:
// открытые члены класса
};

6. Полная форма объявления класса:

class имя класса {
private:
// закрытые члены
protected: // если есть наследование
// защищенные
public:
// открытые члены
};

7. Спецификатор protected при наследовании

При наследовании со спецификаторами:
public– защищенный член базового класса
становится защищенным членом производного
класса,
private– защищенный член базового становится
закрытым в производном классе.
Базовый класс может наследоваться производным
классом со спецификатором protected. В этом
случае открытые и защищенные члены базового
класса становятся защищенными членами
производного класса. Закрытые члены базового
класса остаются закрытыми.

8. Пример. Защищенные члены класса наследуются как открытые

#include <iostream>
class B {//базовый класс
protected: // защищенные члены базового класса
int a,b; // для производного они доступны
public:
void set_ab(int n, int m)
{ a = n; b = m; }
};
class D: public B {//производный класс
int c;//закрытая переменная в производном классе
public : //открытая часть
void set_c(int n) { c = n; }//передача значений закрытым
void show()//вывод закрытых переменных
{std::cout<<a<<" "<<b<<" "<<c;}
};

9. Окончание программы

int main()
{D ob;
int x,y,z;
ctd::cin>>x>>y>>z;// ввод с клавиатуры
ob.set_ab(x, y);// передача значений в базовый
ob.set_c(z); // передача значений в производный
//вывод всех значений через производный класс
ob.show();
return 0;
}

10. Конструкторы, деструкторы и наследование

• Базовый класс, производный класс или оба
могут иметь конструкторы и/или деструкторы.
Конструкторы выполняются в порядке
наследования, а деструкторы в обратном
порядке.
• Когда инициализация проводится только в
производном классе, аргументы передаются
обычным образом. При необходимости
передать аргумент конструктору базового
класса все необходимые аргументы обоих
классов передаются конструктору
производного класса. Затем, используя
расширенную форму объявления конструктора
производного класса, нужные аргументы
отправляются в базовый класс

11. Расширенная форма конструктора производного класса

конструктор_произв_класса(список_арг):
базов_класс (список_арг) {
// тело конструктора производного класса
};
Для базового и производного классов
допустимо использовать одни и те же
аргументы. Для производного класса
допустимо
игнорирование
всех
аргументов и передача их напрямую в
базовый класс

12. Пример. Передача аргумента конструктору базового класса

#include <iostream>
using namespace std;
class B {//базовый
float i;//закрытая переменная
public:
B (float n) {i = n; cout<<"constructor B\n";}//констр. баз-го
~B() {cout<<"destructor B\n";}//деструктор
void show_i() { cout << i << endl; }//вывод в базовом
};
class D: public B {//производный
int j ;
public:
D(int n, float m): B(m){//конструктор производного
j = n; cout<<"constructor D\n";}
~D() {cout<<"destructor D\n";}//деструктор производного класса
void show_j() { cout << j << endl; } //вывод в производном
};

13. Окончание программы

int main(){
D ob(12, 240) ;//определение объекта производного класса
ob.show_i();//вывод закрытой переменной базового класса
ob.show_j();//вывод закрытой переменной производного кл.
return 0;
}

14. Построение иерархии классов

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

15. Построение иерархии классов

#include <iostream>
using namespace std;
class B {
int a;
public:
B(int x) { a = x; }
int geta() { return a; }
};
class D1: public B {
int b;
public:
D1(int x, int y): B(y)
{b = x;}
int getb(){ return b; }
};
class D2: public D1{
int c;
public:
D2(int x, int y, int z): D1(y, z)
{c = x;}
void show() {
cout << geta()<<" "<<getb()<< " ";
cout <<c << " \n " ;}
};
int main()
{D2 ob(1, 2, 3);
ob.show();
cout << ob.geta()<< " " << ob.getb()
<< endl;
return 0;
}

16. Множественное наследование

Производный класс может прямо наследовать более одного
базового класса:
class имя_производного_класса:
сп_доступа имя_базового_1,
сп_доступа имя_базового_2,
...
сп_доступа имя_базового_N
{
//. . . тело производного класса
}
Спецификаторы доступа могут отличаться у разных базовых
классов. Конструкторы выполняются слева направо в порядке,
заданном в объявлении производного класса, а деструкторы – в
обратном.

17. Конструктор при множественном наследовании

Если конструкторам базовых классов необходимы
аргументы, то
производный класс передает их, используя расширенную
форму:
констр_произв_класса(список_арг):
имя_базового1(список_арг),
имя_базового2(список_арг),
...,
имя_базового_N(список_арг)
{
// тело конструктора производного класса
}

18. Конструктор при множественном наследовании

#include <iostream>
using namespace std;
class B1 {
int a;
public:
B1 (int x) { a = x; }
int geta() { return a; }
};
class B2 {
int b;
public:
B2(int x){b = x;}
int getb() { return b; }
};

19. Продолжение примера

// Прямое наследование двух базовых классов
class D: public B1, public B2 {
int c;
public:
D(int x, int y, int z) : B1(z), B2(y)
{c = x;}
void show() {
cout << geta() << " " << getb()<<" ";
cout << c << "\n";}
};
int main()
{D ob(13, 24, 31);
ob.show();
return 0;
}