1、继承的概念和定义
继承是面向对象程序设计上程序复用的重要手段，以往接触的复用都是函数复用，而继承的复用体现在类设计层次上。
继承是一个"is a"，比如一个类叫person，另一个类叫student，student继承person类。
其中person称为基类（父类），student称为派生类（子类）。
class Person
{
protected:
int _age;
};
class Student : public Person
{
protected:
int _stuid;
};
在继承定义格式中：
派生类(子类) 继承方式 基类(子类)
class Student : public Person
{
protected:
int _stuid;
};
在继承方式和访问限定符中有以下关系：
子类访问父类成员，按照 public > protected > private，不大于继承方式下按照自身访问限定符情况访问，不然和继承方式一样。
基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
大部分情况都是public继承。
如果不写继承方式，class默认是private，struct默认是public
比如:
class Person
{
public:
void Print()
{
cout << "age:" << _age << endl;
}
protected:
int _age;
private:
string _name;
};
class Student : public Person
{
protected:
int _stuid;
};
//如果不写继承方式，class默认是private，struct默认是public
class Teacher : Person
{
protected:
int _stuid;
};
对于Student对象，对基类Person中的_age成员访问方式就是protected，只能在派生类Student中访问，不能在类外访问，_name访问方式是private，只能在本身类中访问。
对于Teacher对象，对基类Person中的成员都是private，不可访问。
2、基类和派生类的赋值转换
派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。
在大部分情况父类都不能给子类赋值，能赋值的情况多态谈。
子类赋值给父类，是将子类属于父类的那一份切割再拷贝赋值。
子类地址赋值给父类指针，是父类指针指向子类，但只能读取子类中父类那一部分的大小。
父类引用指向子类，也是指向子类中父类的那一份。
class Person
{
protected:
string _name;
string _sex;
int _age;
};
class Student : public Person
{
public:
int _No;
};
void Test()
{
Student s;
// 1.子类对象可以赋值给父类对象/指针/引用
Person p = s;
Person* pp = &s;
//在之前谈引用时，不同类型在引用时，会发生隐式类型转换
int a = 1;
double b = 1.1;
const int& ra = b; //b会生成临时变量，临时变量具有常性，所以需要带const
//基类引用派生类对象时，不会产生临时变量
Person& rp = s;
//2.基类对象不能赋值给派生类对象
//s = p;
}
int main()
{
Test();
return 0;
}
3、继承中的作用域
在继承中，基类和派生类都有独立的作用域。
在继承中，如果子类和父类分别有两个同名的成员变量，则子类将屏蔽对父类同名成员的访问，需要通过（父类::成员名 进行访问），这种情况叫做隐藏，也叫重定义。
如果子类和父类分别有两个同名的成员函数，也是通过父类::函数名 才能访问父类的同名函数，由于作用域不同，这种情况不能称为重载，也是隐藏或者重定义。
继承体系中应当避免出现同名成员
//成员变量的隐藏
class Person
{
protected:
string _name = "TONY"; // 姓名
int _num = 100; //身份证
};
class Student : public Person
{
public:
void Print()
{
cout << "姓名:" << _name << endl;
cout << "身份证号:" << Person::_num << endl;//访问基类同名成员
cout << "学号:" << _num << endl;
}
protected:
int _num = 1; // 学号
};
void Test1()
{
Student s1;
s1.Print();
};
//成员函数的隐藏
//只要同名就构成隐藏/重定义关系
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
A::fun();
cout << "func(int i)->" << i << endl;
}
};
void Test2()
{
B b;
b.fun(10);
b.A::fun();//必须指明类域进行访问
};
int main()
{
Test1();
Test2();
return 0;
}
4、派生类的默认成员函数
派生类相比于基类除了需要处理自身类内置类型或者自定义类型，还需要处理基类。
class Person
{
public:
Person(const char* name = "peter")
: _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;
}
protected:
string _name;
};
class Student : public Person
{
public:
Student(const char* name, int num)
: Person(name) //直接调用父类的构造
, _num(num)
{
cout << "Student()" << endl;
}
Student(const Student& s)
: Person(s) //父类引用子类对象
, _num(s._num)
{
cout << "Student(const Student& s)" << endl;
}
Student& operator = (const Student& s)
{
cout << "Student& operator= (const Student& s)" << endl;
if (this != &s)
{
Person::operator =(s); //父类引用子类对象
_num = s._num;
}
return *this;
}
~Student()
{
//1、由于先实例化父类，再实例化子类。在析构时在调用子类析构后会默认调用父类析构
//2、父类析构其实和子类析构构成隐藏关系。（由于多态关系需求，所有析构函数都会特殊处理为destructor函数名）
//Person::~Person(); //所以也能调用
cout << "~Student()" << endl;
}
protected:
int _num;
};
int main()
{
Student s("TONY", 3);
return 0;
}
5、继承与友元和静态成员
继承与友元
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员
class Student; //声明
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; //err 类外不能访问
}
void main()
{
Person p;
Student s;
Display(p, s);
}
继承与静态成员
静态成员变量在整个继承体系中只有一份
class Person
{
public:
Person()
{
++_count;
}
void Print()
{
cout << "person" << endl;
}
public:
string _name; // 姓名
static int _count; // 统计人的个数。
};
int Person::_count = 0; //类的静态成员在类外初始化
class Student : public Person
{
protected:
int _stuNum; // 学号
};
// 静态成员属于整个类，所有对象。同时也属于所有派生类及对象
int main()
{
Person p;
Student s;
p._count++;
s._count++;
cout << p._count << endl;
cout << s._count << endl;
cout << &p._count << endl;
cout << &s._count << endl;
cout << Person::_count << endl;
cout << Student::_count << endl;
//类的空指针可以访问不在对象中的成员
Person* ptr = nullptr;
//cout << ptr->_name << endl; // no _name在对象中
ptr->Print(); // ok Print函数不在对象中
cout << ptr->_count << endl; // ok _count不在对象中
(*ptr).Print(); // ok
cout << (*ptr)._count << endl; // ok
return 0;
}
6、复杂的菱形继承及菱形虚拟继承
在实际中，应该避免设计菱形继承体系，因为容易使得代码结构复杂。
下面只是学习了解
单继承：一个子类只有一个直接父类的继承关系称为单继承。
多继承：一个子类有两个或以上父类的继承关系称为多继承。
菱形继承：菱形继承是继承的一种复杂形式
菱形继承的问题在于，菱形继承有数据冗余和二义性的问题。
数据冗余：如上图中Assistant类中继承的Teacher和Student类都继承了Person，对应对象存了两份Person的数据。
二义性：因为有两份Person的数据，所以无法明确哪一份数据。
class Person
{
public:
string _name;
};
class Student : public Person
{
protected:
int _num;
};
class Teacher : public Person
{
protected:
int _id;
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse;
};
void Test()
{
// 二义性无法明确访问的是哪一个
Assistant a;
//a._name = "peter"; //err
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
}
数据冗余问题解决方法：虚拟继承
在继承体系中间部分Student和Teacher继承Person上添加virtual。
...
class Student : virtual public Person
{
protected:
int _num;
};
class Teacher : virtual public Person
{
protected:
int _id;
};
...
虚拟继承解决数据冗余的原理
先看代码
//菱形进程
class A
{
public:
int a;
};
class B : public A
{
public:
int b;
};
class C : public A
{
public:
int c;
};
class D : public B, public C
{
public:
int d;
};
int main()
{
D dd;
dd.d = 1;
dd.b = 2;
dd.c = 3;
dd.B::a = 5;
dd.C::a = 6;
return 0;
}
首先在未添加virtual前，D类对象数据内存如下。
设计成菱形虚拟继承后
//菱形虚拟进程
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 dd;
dd.d = 1;
dd.b = 2;
dd.c = 3;
dd.B::a = 5;
dd.C::a = 6;
dd.a = 4;
return 0;
}
左边两个指针叫虚基表指针，右边两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A（是找到A，而不是专门找到a）。
一样的代码，再给A类添加一个成员变量a1，用B类对象调用a和a1，一样还是通过虚基表确定A。
理解以上后，如果碰到需要计算对象大小的题，也能解决。
比如
//菱形进程
class A
{
public:
int a;
//int a1;
};
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;
//A中没有a1就是24字节，4个成员变量加上两个指针。
//带上a1就是28字节，在之前基础上加上a1大小。
cout << sizeof d << endl;
return 0;
}
并且，先继承的父类，在地址上和子类是一样的。
class A
{
public:
int a;
};
class B
{
public:
int b;
};
class C : public B, public A
{
public:
int c;
};
int main()
{
C c;
A* pa = &c;
B* pb = &c;
C* pc = &c;
return 0;
}
7、继承和组合
继承是一种白箱复用，在已知类中细节，实现一个新的类。
组合是一种黑箱复用，组合要求组合对象有好的接口，对象中细节不可见
实际应该多用组合。组合耦合性低，代码维护性好。继承也有用武之地，有些关系合适就使用继承。
本章完~
1984
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
