1、继承的概念和定义
继承( inheritance)机制是面向对象程序设计使代码可以复用的重要手段，他允许在保留原有类特性的基础上进行扩展，增加功能，产生新的了，类，叫做派生类。
lass Person { public: void Print() { cout << "name:" << _name << endl; cout << "age:" << _age << endl; } protected: string _name = "peter"; // 姓名 int _age = 18; // 年龄 }; // 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了 //Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可 //以看到变量的复用。调用Print可以看到成员函数的复用。 class Student : public Person { protected: int _stuid; // 学号 }; class Teacher : public Person { protected: int _jobid; // 工号 };
继承的定义格式
person 叫做父类或者基类，student叫做子类，或者派生类，
继承关系和访问限定符
总结：
1.基类的privete成员在派生类中无论以什么方式继承都是不可见的，但是他确实在派生类中存在，只是无法直接去访问他，可以间接的去访问；
2.如果基类成员不想在类外被访问，但需要在派生类中访问，就定义为protected。 可以看出保护成员限定符是因为继承才出现的
3.当我们总结一下上面的表格，有两点规律;
1.基类的private成员在派生类中不可见
2.基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，
public > protected> private。
取权限较小的为基类在派生类中的访问方式；
4.使用关键字class 时默认的继承方式是private 使用struct 时默认的继承方式是public ，不过最好是显式的写出继承方式；
5.我们最常用的都是使用public 继承，很少使用protected/private继承；
class Person { public : void Print () { cout<<_name <<endl; } protected : string _name ; // 姓名 private : int _age ; // 年龄 }; //class Student : protected Person //class Student : private Person class Student : public Person { protected : int _stunum ; // 学号 };
2、基类和派生类对象赋值转换
派生类可以赋值给基类的对象，基类的指针，基类的引用。这个说法叫做切片或者切割,比如：
我们可以将派生类的一部分赋值给基类，但是不能将基类赋值给派生类，因为有的变量基类是没有，无法完成赋值；
class Person { protected: string _name; // 姓名 string _sex; // 性别 int _age; // 年龄 }; class Student : public Person { public: int _No; // 学号 }; void Test() { Student sobj; // 1.子类对象可以赋值给父类对象/指针/引用 Person pobj = sobj; Person* pp = &sobj; Person& rp = sobj; //2.基类对象不能赋值给派生类对象 sobj = pobj; // 3.基类的指针可以通过强制类型转换赋值给派生类的指针 pp = &sobj; Student * ps1 = (Student*)pp; // 这种情况转换时可以的。 ps1->_No = 10; pp = &pobj; Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题 ps2->_No = 10; }
第三点我们以后也会细讲
3、继承中的作用域
1.在继承体系中基类和派生类都有独立的作用域
2.在子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义(在子类成员中，可以使用基类::基类成员 进行显式访问 )
3.需要注意的是，如果是成员函数的隐藏，只需要函数名相同就构成隐藏
4.注意在实际中在继承体系里最好不要定义同名的成员；
// B中的fun和A中的fun不是构成重载，因为不是在同一作用域 // B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。 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; } }; vo
注意函数重载和隐藏的区别；
4、派生类中的默认成员函数
关于六个默认函数，派生类中又会有什么改变呢？
1. 关于默认构造函数，对于内置类型不做处理，对于自定义类型调用自定义类型的默认构造函数，对于父类成员，当成一个整体的自定义类型，调用父类的默认构造函数，如果父类没有默认构造函数，就会报错，也可以在派生类中通过初始化列表的方式调用父类的构造函数
2.关于拷贝构造，对于父类会调用父类的拷贝构造，如果父类没有拷贝构造，就会报错；
3.关于赋值运算符重载，会调用父类的赋值运算符重载；
4.关于析构函数，先调用子类的析构函数，再调用父类的析构函数；
5.派生类对象初始化先调父类构造，再调用子类构造，析构清理先调用子类析构再调用父类析构；
class Person { public: Person(const char* name) : _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(int num, const char* str, const char* name) :Person(name)// 父类+自己，父类 调用父类构造函数初始化（复用） , _num(num) , _str(str) { cout << "Student()" << endl; } // s2(s1) Student(const Student& s) :Person(s) , _num(s._num) , _str(s._str) {} Student& operator=(const Student& s) { if (this != &s) { Person::operator=(s);//调用父类的赋值运算符 _num = s._num; _str = s._str; } return *this; } // 子类的析构也会隐藏父类 // 因为后续多态的需要，析构函数名字会被统一处理成destructor ~Student() { // 显式写无法先子后父 //Person::~Person(); cout << _name << endl; cout << "~Student()" << endl; // 注意，为了析构顺序是先子后父，子类析构函数结束后会自动调用父类析构 } protected: int _num; //学号 string _str; // 父类成员，当成一个整体的一个自定义类型成员 // 子类的成员 // a、内置类型 // b、自定义类型 }; int main() { Student s1(1, "xxxx", "张三"); Student s2(s1); Student s3(2, "yyy", "李四"); s1 = s3; Person p("李四"); p.~Person(); return 0; }
该程序：
先调用s1的person() 和 student() ， 然后调用s2的 Person(const Person& p) ， 然后调用s3的person() 和 student() ， 然后调用s1的Person operator=(const Person& p) ，然后调用p的Person()，然后调用p的~Person()
然后按照先构造的后析构，先析构子类，再析构父类的规则
调用p的~Person()，然后调用s3的李四 ~Student() ~Person() ， 然后调用s2的张三 ~Student() ~Person() ，然后调用s1的李四 ~Student() ~Person()
最后结束！
5、继承与友元、静态函数的关系
友元关系不能继承，也就是说基类的友元函数不能访问派生类的私有和保护成员；
基类定义了static静态成员，则整个继承体系中只有一个这样的成员，无论派生出多少个子类，都只有一个stdtic成员实例；
这段代码执行了四次person() 构造，_count++了四次，所以我们看到的人数是4，然后student类中的_count清零，则person类中的_count也变成0了；
可以看出，静态成员在继承体系中只有一份；
6、复杂的菱形继承及其虚拟菱形继承
单继承：一个子类只继承一个父类的时候，称为单继承；
多继承：一个子类有两个或两个直接父类时，称这个继承关系为多继承；
菱形继承是多继承的一种特殊情况；
菱形继承会有数据冗余和二义性的问题，比如：
在assitant类中有两份person类的成员，而且当assitant类和person类中出现相同名字的成员函数或者变量时，调用该函数或者变量，会出现二义性，就是编译器不知道该调用哪个函数；
当然我们可以显式指定访问哪个父类的成员可以解决二义性问题；那么数据冗余该怎么解决呢？
虚拟继承可以解决菱形继承数据冗余的问题，比如：
class Person { public : string _name ; // 姓名 }; class Student : virtual public Person { protected : int _num ; //学号 }; class Teacher : virtual public Person { protected : int _id ; // 职工编号 }; class Assistant : public Student, public Teacher { protected : string _majorCourse ; // 主修课程 }; void Test () { Assistant a ; a._name = "peter"; }
我们可以在菱形继承的腰部虚拟继承父类，这样的话父类重复继承的成员就会单独存放在一个空间，子类用的时候都可以调用，
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; return 0; }
虚拟继承解决数据冗余和二义性的原理(比较复杂，目前学习的还不清楚，以后会慢慢学习);
7、继承和组合
pubilc继承是一种is-a的关系，也就是说每个派生类对象都是一个基类对象；
组合是一种has-a的关系，比如B组合了A，那么每个B对象中都有一个A对象；
Tire和Car就是一种组合关系，
继承和组合的区别：
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合
我们要尽量低耦合，高内聚，就是避免代码与代码之间联系过多，然后也要很好的实现相应的功能
