继承
1.继承的概念及定义
1.1 继承的概念
继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。
1.2 继承定义
1.2.1 定义格式
下图Base是父类，也称作基类。 Derived是子类，也称作派生类。
1.2.2 继承关系和访问限定符
1.2.3 继承基类成员访问方式的变化
| 类成员的继承方式 | public继承 | protected继承 | private继承 |
|---|---|---|---|
| 基类的public成员 | 派生类的public成员 | 派生类的protected成员 | 派生类的private成员 |
| 基类的protected成员 | 派生类的protected成员 | 派生类的protected成员 | 派生类的private成员 |
| 基类的private成员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可见 |
总结：
- 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
- 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
- 基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
- 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
1.3 多继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
class B1
{
public:
int _b1;
};
class B2
{
public:
int _b2;
};
class D : public B1, public B2
{
public:
int _d;
};
int main()
{
D d;
d._b1 = 1;
d._b2 = 2;
d._d = 3;
return 0;
}
2.基类和派生类对象赋值转换
- 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。(例如：狗是动物)
- 基类对象不能赋值给派生类对象。(动物是狗，这个就是错的)
- 基类的指针可以通过强制类型转换赋值给派生类的指针。
class Person
{
protected:
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public:
int _No; // 学号
};
void Test()
{
Student a;
// 1.子类对象可以赋值给父类对象/指针/引用
Person b = a;
Person* c = &a;
Person& d = a;
//2.基类对象不能赋值给派生类对象
// a = b;
// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
c = &a;
Student * ps1 = (Student*)c; // 这种情况转换时可以的。
cout << ps1->_No << endl;
ps1->_No = 10;
cout << ps1->_No << endl;
}
3.继承中的作用域
- 在继承体系中基类和派生类都有独立的作用域。
- 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫同名隐藏，也叫重定义。
- 成员函数的隐藏，只需要函数名相同就构成同名隐藏。
- 同名隐藏时，访问基类对象可以 通过基类::对象名
class Base
{
public:
void SetInfo(int b)
{
_b = b;
}
void func()
{
cout << "Base::func()" << endl;
}
int _b;
};
class Derived : public Base
{
public:
// 子类将来会从基类中继承 void SetInfo(int b)
void SetInfo(int b, int d)
{
_b = b;
_d = d;
}
void func()
{
_b = 100;
//Base::_b = 200;
//__super::_b = 20;
cout << "Derived::func()" << endl;
}
int _d;
//int _b;
char _b;
};
int main()
{
Derived d;
d.SetInfo(1, 2);
d.Base::SetInfo(10);
//d._b = 100;
//d.Base::_b = 200;
d.func();
d.Base::func();
return 0;
}
4.派生类的默认成员函数
6个默认成员函数，“在派生类中，这几个成员函数是如何生成的呢？
- 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显式调用。
- 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
- 派生类的operator=必须要调用基类的operator=完成基类的复制。
- 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
- 派生类对象初始化 先调用基类构造再调派生类构造。 \color{blue}{先调用基类构造再调派生类构造。} 先调用基类构造再调派生类构造。
- 派生类对象析构清理先调用派生类析构再调基类的析构
class Base
{
public:
Base(int b = 0)
: _b(b)
{}
Base(const Base& b)
: _b(b._b)
{}
Base& operator=(const Base& b)
{
if (this != &b)
{
_b = b._b;
}
return *this;
}
protected:
int _b;
};
class Derived : public Base
{
public:
Derived(int b, int d)
:Base(b)
,_d(d)
{
_p = new int[10];
}
~Derived()
{
delete[] _p;
}
Derived(const Derived& d)
: Base(d)
, _d(d._d)
{
_p = new int[10];
}
Derived& operator=(const Derived& d)
{
if (this != &d)
{
// 不能用d中Base的部分给 *this 中 Base部分 赋值
// *this = d; // 无限递归
Base::operator=(d);
// 子类自己新增加的成员赋值
_d = d._d;
delete[] _p;
_p = new int[10];
// 下一步是 d._p空间中的内容拷贝到_p
}
return *this;
}
protected:
int _d;
int* _p;
};
class Base
{
public:
Base(int b = 0)
: _b(b)
{}
~Base()
{
cout << "Base::~Base()" << endl;
}
protected:
int _b;
};
class Derived : public Base
{
public:
Derived(int b, int d)
: Base(b)
, _d(d)
{}
~Derived()
{
cout << "Derived::~Derived()" << endl;
// 编译器在子类析构函数最后一个语句之后
// call Base::~Base();
}
protected:
int _d;
};
5.继承与友元
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员
class B
{
friend void Print(const B& b);
public:
B(int b)
: _b(b)
{}
protected:
int _b;
};
class D : public B
{
public:
D(int b, int d)
: B(b)
, _d(d)
{}
protected:
int _d;
};
void Print(const B& b)
{
cout << b._b << endl;
D d(1, 2);
cout << d._b << endl;
// 编译报错
// 友元关系不能继承
//cout << d._d << endl;
}
6. 继承与静态成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。
class B
{
public:
B(int b)
: _b(b)
{
_count++;
}
B(const B& b)
: _b(b._b)
{
_count++;
}
~B()
{
--_count;
}
int _b;
static int _count;
};
int B::_count = 0;
class D1 : public B
{
public:
D1(int b)
: B(b)
{}
void func()
{
cout << _count << endl;
}
};
class D2 : public B
{
public:
D2(int b)
: B(b)
{}
void func()
{
cout << _count << endl;
}
};
int main()
{
cout << sizeof(D1) << endl; // 大小为 4 ---------静态成员不包含在类的对象中，计算大小也不用计算他
D1 d1(2);
D2 d2(1);
cout << d1._count << endl;
cout << d2._count << endl;
cout << &d1._count << endl;
cout << &d2._count << endl;
cout << &D1::_count << endl;
cout << &D2::_count << endl;
return 0;
}
7.复杂的菱形继承及菱形虚拟继承
7.1 菱形继承
单继承：一个子类只有一个直接父类时称这个继承关系为单继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
菱形继承：菱形继承是多继承的一种特殊情况(如下):
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在D的对象中_b会有两份(红色所示)。
class B
{
public:
void func()
{
cout << "B::func()" << endl;
}
int _b;
};
class C1 : public B
{
public:
int _c1;
};
class C2 : public B
{
public:
int _c2;
};
class D : public C1, public C2
{
public:
int _d;
};
int main()
{
cout << sizeof(D) << endl; //20
D d;
// 菱形继承二义性问题
// d._b = 1;
// d.func();
// 如何解决？
// 1. 让访问明确化---当d访问最顶层成员时候，直接加上其父类的名称
d.C1::func();
d.C2::func();
d.C1::_b = 1;
d._c1 = 2;
d._c2 = 4;
d._d = 5;
// 2. 解决方式：让最顶层基类中成员在d中只存储一份
// 菱形虚拟继承
return 0;
}
7.2 菱形继承二义性解决方法
7.2.1 虚拟继承
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。
class B
{
public:
void func()
{
cout << "B::func()" << endl;
}
int _b;
};
class D : virtual public B
{
public:
D()
{
_d = 10;
}
int _d;
};
int main()
{
cout << sizeof(D) << endl; //12
D d;
d._b = 1;
d._d = 2;
return 0;
}
7.2.2 虚拟继承原理
如果基类和子类都没有定义构造函数，则编译器会给子类生成一份默认的构造函数。
如果子类的构造函数显式定义了，则编译器会对子类的构造函数进行修改 ------ 目的：给对象前4个字节进行赋值
虚拟继承一般不会应用于单继承，虚拟继承主要是用来实现菱形虚拟继承的，目的：解决菱形继承中的二义性问题
7.2.3 菱形虚拟继承
class B
{
public:
void func()
{
cout << "B::func()" << endl;
}
int _b;
};
class C1 : virtual public B
{
public:
int _c1;
};
class C2 : virtual public B
{
public:
int _c2;
};
class D : public C1, public C2
{
public:
int _d;
};
int main()
{
cout << sizeof(D) << endl; // 24
D d;
d._b = 1;
d._c1 = 2;
d._c2 = 3;
d._d = 4;
//采用菱形虚拟继承解决：菱形继承中二义性问题
//将最顶层B中的成员在D中只继承一份
d._b = 1;
d.func();
C1& c1 = d;
c1._b = 10;
C2& c2 = d;
c2._b = 20;
d._b = 30;
return 0;
}
示意图：
8.继承和组合
继承是一种 is-a 的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种 has-a 的关系。假设B组合了A，每个B对象中都有一个A对象。
继承允许你根据基类的实现来定义派生类的实现。在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。对象组合要求被组合的对象具有良好定义的接口。对象的内部细节是不可见的。 组合类之间没有很强的依赖关系，耦合度低。
尽量多去用组合，而不是类继承 。组合的耦合度低，代码维护性好。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
