明智的使用继承会为你带来好处

继承

为什么要有继承？？
有些时候，我们要写好几段功能相似但又不同的代码，但是这些功能相似的代码重复的去写，就会显得冗余，这时就可以将这段代码分离出来，再让其他想要使用这段功能的类直接继承即可使用，而不出现冗余代码，提高了效率。
在C++中，继承又分为单继承和多继承。单继承比多继承要简单的多。

继承的特点
1、析构时先析构子类的，再析构父类的
2、派生类的构造函数应在其初始化表里调用基类的构造函数。
3、在编写派生类的赋值函数时，注意不要忘记对基类的数据成员重新赋值
4、派生类不可能继承基类的构造函数、析构函数、赋值函数
5、基类的私有成员在派生类中不可见
6、is-a：在public继承下产生的，因为一个子类就是父类
7、has-a：在私有和保护继承下出现，不支持赋值兼容规则
何为赋值兼容规则：
1.子类对象可以赋值给父类对象（切割/切片）
2. 父类对象不能赋值给子类对象
3. 父类的指针/引用可以指向子类对象
4. 子类的指针/引用不能指向父类对象（可以通过强制类型转换完成）
单继承：只有一个父类
多继承：有两个或两个以上父类，多继承里又包含了一个菱形继承

单继承的方式如下：

class A
{
public:
     void test1()
    {
        cout << "class A" << endl;
    }
private:
    int _a;
};
class B : public A
{
public:
     void test()
    {
        cout << "class B" << endl;
    }
private:
    int _b;
};
int main()
{
    //A a;
    B b;
    b.test1();
    b.test();
    system("pause");
    return 0;
}

~继承的关键符号为：（一个冒号），后面再跟上限定修饰符以及要继承的父类类名。

~子类如果和父类有相同的成员函数，子类在调用时会先调用自己的成员函数。这叫就近原则
继承有几个原则：

1、子类对象可以赋值给父类对象，但是父类对象不能赋值给子类对象。

2、父类的指针/引用可以指向子类对象，子类对象的指针/引用不能指向父类对象。

当编译器足够强大时，当我们把父类赋值给子类时，会直接在语句下面出现一条红波浪线告诉我们不能这样使用。

多继承：

class A
{
public:
    void test()
    {
        cout << "class A" << endl;
    }
private:
    int _a;
};

class B 
{
public:
    void test()
    {
        cout << "class B" << endl;
    }
private:
    int _b;
};
class C : public A, public B
{
public:
    void test()
    {
        cout << "class C" << endl;
    }
private:
    int _c;
};
int main()
{
    //A a;
    //B b;
    C c;
    c.test();
    c.B::test();
    c.A::test();
    //b.test();
    system("pause");
    return 0;
}

多继承时，在子类的类名后面加上多个父类，父类中间用逗号隔开。如果子类的成员函数与父类的相同，如果想要访问父类的成员函数，需要指定类域才能进行访问。

菱形继承

class A
{
public:
    void test()
    {
        cout << "class A" << endl;
    }
private:
    int _a;
};
class B:public A
{
public:
    void test()
    {
        cout << "class B" << endl;
    }
private:
    int _b;
};
class C:public A
{
public:
    void test()
    {
        cout << "class C" << endl;
    }
private:
    int _c;
};
class D:public B,public C
{
public:
    void test()
    {
        cout << "class D" << endl;
    }
private:
    int _d;
};
int main()
{
    A a;
    B b;
    C c;
    D d;
    d.test();
    system("pause");
    return 0;
}

如此便是菱形继承，我们可以很明显的看到在最后的子类D中存在着两个相同的A类，我们称为这为冗余。并且在程序调用时会产生二义性，即程序不知道该调用哪一个父类里面的A。

那么该如何解决多重继承里出现的这种问题？？这里就引出了虚继承的概念。
虚继承：关键字：virtual

如何为虚继承？？

*在声明派生类时，将关键字 virtual 加到相应的继承方式前面。经过这样的声明之后，当基类通过多条派生路径被一个派生类继承时，该派生类只继承一次该基类的成员。

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._a = 10;
    d._b = 20;
    d._c = 30;
    d._d = 40;
    system("pause");
    return 0;
}

虚继承虽然解决了问题，但是在一般情况下最好还是不用菱形继承的好，因为没有菱形继承就不会有虚继承。所以我们尽量在写代码时避免出现菱形继承。