c 继承详解-ag真人游戏

继承的概念及定义

继承的概念

继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承使类设计层次的复用。

class person
{
public:
    void print()
    {
        cout << "name:" << _name << endl;
        cout << "age:" << _age << endl;
    }
protected:
    string _name = "peter"; 
    int _age = 18; 
};
class student : public person
{
protected:
    int _stuid;
};
int main()
{
    student s;
    s.print();
    return 0;
}

以上代码中，继承后父类person的成员(成员函数成员变量)都会变成子类的一部分。student复用了person的成员。

继承定义

定义格式

继承关系和访问限定符

继承基类成员访问方式的变化

类成员/继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protectde成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的protected成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可见

总结：
1.基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是会被继承到派生类对象中，但是语法上限制派生类对象不管在类里面还是在类外面都不能去访问它。
2.基类private成员在派生类中不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3.基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式==min(成员在基类的访问限定符，继承方式)，public -> protected -> private。
4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示写出继承方式。
5.在实际运用中一般都是用public继承，几乎很少使用protected/private继承。protected/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

1.派生类对象可以赋值给基类的对象/基类的指针/基类的引用，也称为切片或切割。
2.基类对象不能赋值给派生类对象。
3.基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用rtt的dynamic cast来进行识别后进行安全转换。

#define _crt_secure_no_warnings
#include 
using namespace std;
class person
{
public:
    void print()
    {
        cout << "name:" << _name << endl;
        cout << "age:" << _age << endl;
    }
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;
}

1.在继承体系中基类和派生类都有独立的作用域。
2.子类和父类中有同名成员时，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用基类::基类成员显示地访问）
3.需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏
4.在实际中继承体系里面组好不要定义同名的成员

以下代码中，student的_num和person的_num构成隐藏关系，这样代码虽然能跑，但非常容易混淆。
student中的fun和a中的fun不构成函数重载，因为不在同一作用域。它们构成隐藏，成员函数满足函数名相同时就构成隐藏。

class person
{
  
public:
    void fun()
    {
  
        cout << "func()" << endl;
    }
protected:
    string _name; 
    int _num; 
};
class student : public person
{
  
public:
    void fun(int i)
    {
  
        cout << "func(int i)->" << i << endl;
    }
    void print()
    {
  
        cout << "num:" << _num << endl;
    }
protected:
    int _num = 10;
};
void test()
{
  
    student s1;
    s1.print();
    s1.fun(1);
}

1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段调用。
2.派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝构造初始化。
3.派生类的operator=必须要调用基类的operator=完成基类的赋值。
4.派生类的析构函数会在被调用完成后自动调用析构函数清理基类成员函数。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5.派生类对象初始化先调用基类构造再调用派生类构造。
6.派生类对象析构清理先调用派生类析构再调用基类析构。

class person
{
  
public:
    person(const char* name = "perter")
        :_name(name)
    {
  
        cout << "person()" << endl;
    }
    person(const person& p)
    {
  
        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()
    {
  
        cout << "~student()" << endl;
    }
protected:
    int _num;
};
void test()
{
  
    student s1("jack", 18);
    student s2(s1);
    student s3("rose", 17);
    s1 = s3;
}

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

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; 报错
}

基类定义了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 _course;
};
void testperson()
{
  
    student s1;
    student s2;
    student s3;
    graduate s4;
    cout << "人数：" << person::_count << endl;
    student::_count = 0;
    cout << "人数：" << person::_count << endl;
}
int main()
{
  
    testperson();
    return 0;
}

菱形继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
菱形继承：是多继承的一种特殊情况。

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在assistant的对象中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 _mahorcourse;
};
void test()
{
  
    //有二义性，无法明确知道访问的是哪一个
    assistant a;
    //a._name = "peter";
    //需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
    a.student::_name = "xxx";
    a.teacher::_name = "yyy";
}

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在student和teacher的继承person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方使用。
（在菱形腰部使用）

class student :virtual public person
class teacher :virtual public person

虚拟继承解决数据冗余和二义性的原理

为了研究虚拟继承原理，给出一个简化的菱形继承体系，再借助内存窗口观察对象成员的模型。

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 d;
    d.b::_a = 1;
    d.c::_a = 2;
    d._b = 3;
    d._c = 4;
    d._d = 5;
    return 0;
}

下面是菱形继承的内存对象成员模型：这里可以看到数据冗余

下图是菱形虚拟继承的内存对象成员模型：可以看到d对象中将a放到了对象组成的最下面，这个a同时属于b和c。这里是通过了b和c的两个指针指向的一张表。这两个指针叫做虚基表指针，这两个表叫做虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的a

访问继承的虚基类对象成员_a，都是取偏移量计算_a的位置。
b的对象、指针、引用、访问_a，都要取偏移量计算_a的位置。
可以看到虚继承后，能解决菱形继承。但是同时，对象模型更复杂了；其次访问虚基类成员也要付出一定效率代价。

有了多继承，就存在菱形继承，有了菱形继承，就有菱形虚拟继承，底层实现就很复杂。所以一定不要设计出菱形继承，否则在复杂度及性能上都有问题。多继承可以认为是c 的缺陷之一，很多后来的oo语言都没有多继承，如java。

继承和组合
1.public继承是一种is-a的关系，也就是每个派生类对象都是一个基类对象。class b : public a {}
2.组合是一种has-a的关系。假设b组合了a，每个b对象中都有一个a对象。 class b {a _a;}
优先使用对象组合，而不是类继承。
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
4.对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于保持每个类被封装。
5.实际尽量多用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地，有些关系适合继承就用继承；另外要实现多态，也必须要继承。类之间的关系可以用继承，也可以用组合时，就用组合。