目录
继承的概念
继承定义
继承基类成员访问方式
基类和派生类对象的赋值转换
继承中的作用域
派生类的默认成员函数
友元关系不能继承
基类static成员
菱形继承与菱形虚拟继承
虚拟继承解决数据冗余和二义性的原理
继承和组合
继承的概念
继承是类层次的复用。
继承定义
// 派生类 继承方式 基类
struct Student : public Person
{
};继承的使用
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "perter";
int _age = 18;
private:
int _aa;
};
//继承后父类的成员（成员函数+成员变量）都会变成子类的一部分
struct Student :public Person
{
public:
void f()
{
//_aa = 1 // 不可见
}
protected:
int _stuid;
};
class Teacher :public Person
{
protected:
int _jobid;
};继承基类成员访问方式
| public继承 | protected继承 | private继承 | |
| 基类的public成员 | 派生类的public成员 | 派生类的protected成员 | 派生类的private成员 |
| 基类的protected成员 | 派生类的protected成员 | 派生类的protected成员 | 派生类的private成员 |
| 基类的private成员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可见 |
总结：
1.基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2.如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。
3.基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
基类和派生类对象的赋值转换
class Person
{
protected:
string _name;
string _sex;
public:
void f()
{
_age = 1;
}
private:
int _age;
};
class Student : public Person
{
public:
int _No;
};
int main()
{
Person p;
Student s;
//父类 = 子类 赋值兼容 -> 切割 切片
//这里不存在类型转换，是语法天然支持行为
p = s;
Person* ptr = &s;
ptr->f();
//ptr->_age = 1;
Person& ref = s;
//子类 = 父类
//s = (Student)p; // 不行
Student* pptr = (Student*)&p;
Student& rref = (Student&)p;
//很危险的，存在越界访问的风险
//pptr->_No = 1;
return 0;
}继承中的作用域
1
. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，
也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
3. 需要注意的是如果是
成员函数的隐藏
，只需要
函数名相同
就构成隐藏。
//A 和 B的func构成函数隐藏
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B :public A
{
public:
void fun(int i)
{
cout << "func(int i)->" << i << endl;
}
};
void Test()
{
B b;
b.fun(1);
//b.fun() //被隐藏了，所以调不动
b.A::fun();
}派生类的默认成员函数
1. 派生类的
构造函数
必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认
的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的
拷贝构造函数
调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的
operator=
要调用基类的operator=完成基类的复制。
4. 派生类的
析构函数
会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能
保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调派生类构造。
6. 派生类对象析构清理先调用派生类析构再调基类的析构。
7. 有些场景析构函数需要构成重写，重写的条件之一是函数名相同，编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。
class Person
{
public:
Person(const char* name = " hh") //没有默认构造函数的话派生类就要写了
:_name(name)
{
cout << "Person()" << endl;
}
Person(const Person& p)
:_name(p._name)
{
cout << "Person(const Person& p)" << endl;
}
Person& operator=(const Person& p)
{
cout << "Person operator=(const Person& p)" << endl;
if (this != &p)
_name = p._name;
return *this;
}
~Person()
{
cout << "~Person()" << endl;
//delete[] _ptr;
}
protected:
string _name;
//int* _ptr = new int[10];
};
class Student : public Person
{
public:
Student(const char* name = "张三", int num = 1)
:Person(name)
, _num(num)
{}
//s2(s1)
Student(const Student& s)
:Person(s)
, _num(s._num)
{}
//s2 = s1
Student& operator=(const Student& s)
{
if (this != &s)
{
Person::operator = (s);
_num = s._num;
}
return *this;
}
//析构函数名字会被统一处理成destructor()
//所以子类的析构函数跟父类的析构函数就构成隐藏
~Student()
{
//Person::~Person();
//delete[] _ptr;
}
//子类析构函数结束时，会自动调用父类的析构函数
//不需要显示调用父类析构函数
//这样才能保证先析构子类成员，再析构父类成员
protected:
int _num = 1;
//string _s = "hellllllllllllllllllllllllllo";
//int* _ptr = new int[10];
};
//不写，编译器默认生成的派生的构造、析构和operator=
//父类继承下来的：调用父类默认构造和析构、operator= 处理 自己的：跟普通类一样
// 什么情况下自己写？
// 1、父类没有默认构造，需要我们自己显示写构造
// 2、如果子类有资源需要释放，就需要自己显示写析构
// 3、如果子类存在浅拷贝问题，就需要自己实现拷贝构造和赋值解决浅拷贝问题
// 如果我们要自己写怎么办？如何写？
// 父类成员调用父类的对应构造、拷贝构造、operator=和析构处理
// 自己成员按普通类处理。
int main()
{
Student s1;
Student s2(s1);
//Student s3("jack", 18);
//s1 = s3;
return 0;
}友元关系不能继承
class Person
{
public:
friend void Display(const Person& p, const Student& s);
protected:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
cout << p._name << endl;
cout << s._stuNum << endl;
}
void main()
{
Person p;
Student s;
Display(p, s);
}基类static成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子
类，都只有一个static成员实例 。
class Person
{
public:
Person()
{
++_count;
}
protected:
string _name;
public:
static int _count;
};
int Person::_count = 0;
class Student :public Person
{
protected:
int _stuNum;
};
class Graduate :public Student
{
protected:
string _seminarCourse;
};
int main()
{
Person p;
Student s;
Graduate g;
cout << Person::_count << endl;
cout << Student::_count << endl;
cout << Graduate::_count << endl;
return 0;
} 菱形继承与菱形虚拟继承
单继承：一个子类只有一个直接父类
多继承：一个子类有两个或以上直接父类
菱形继承：是多继承的一种特殊情况
菱形继承有数据冗余和二义性的问题。
class Person
{
public:
string _name;
int _a[1000];
};
class Student :public Person
{
public:
int _num;
};
class Teacher :public Person
{
public:
int _id;
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse;
};
int main()
{
//二义性、数据冗余
Assistant a;
a._id = 1;
a._num = 2;
a.Student::_name = "小张";
a.Teacher::_name = "张老师";
cout << sizeof(a) << endl;
return 0;
}
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。
//虚继承解决数据冗余和二义性
class Person
{
public:
string _name;
int _a[1000];
};
class Student : virtual public Person
{
public:
int _num;
};
class Teacher : virtual public Person
{
public:
int _id;
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse;
};
int main()
{
//二义性、数据冗余
Assistant a;
a._id = 1;
a._num = 2;
a.Student::_name = "小张";
a.Teacher::_name = "张老师";
cout << sizeof(a) << endl;
return 0;
}虚拟继承解决数据冗余和二义性的原理
以下代码为例
class A
{
public:
int _a;
};
class B : virtual public A
{
public:
int _b;
};
class C :virtual public A
{
public:
int _c;
};
class D : public B, public C
{
public:
int _d;
};
int main()
{
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
d._a = 0;
return 0;
}A一般叫虚基类，在D里面，A放到一个公共位置，那么BC有时需要找A，通过B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。
继承和组合
1.public继承是一种is-a的关系。每个派生类对象都是一个基类对象。组合是一种has-a的关系。B组合了A，那么每个B对象中都有一个A对象。
2.优先使用对象组合。
3.继承是根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)，一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
4.对象组合是继承之外的另一种复用选择。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。
5.优先使用对象组合有助于保持每个类被封装。组合的耦合度低，代码维护性好。
6.要实现多态，也必须要继承。
