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

继承

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

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

单继承的方式如下&＃xff1a;

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

~继承的关键符号为&＃xff1a;&＃xff08;一个冒号&＃xff09;&＃xff0c;后面再跟上限定修饰符以及要继承的父类类名。

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

1、子类对象可以赋值给父类对象&＃xff0c;但是父类对象不能赋值给子类对象。

2、父类的指针/引用可以指向子类对象&＃xff0c;子类对象的指针/引用不能指向父类对象。

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

多继承&＃xff1a;

class A
{
public:void test(){cout <<"class A" <private:int _a;
};class B
{
public:void test(){cout <<"class B" <private:int _b;
};
class C : public A, public B
{
public:void test(){cout <<"class C" <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;
}

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

菱形继承

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

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

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

如何为虚继承&＃xff1f;&＃xff1f;

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

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

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