- 继承的本质
继承的本质是一种复用，即保持原有类的特之外，还可以进行扩展。而继承后由于扩展就会产生其他复杂的问题，以下会会列举出继承产生的主要问题，并对问题进行分析
- 继承产生的二义性及数据冗余的问题
在多继承时，如果父类都继承了同一个类,这时就不能直接访问父类的成员，而是必须指定是哪个类（如f.Derived1::show();）。
#include <iostream>
class Base {
public:
Base(int val) : baseValue(val) {}
void show() const { std::cout << "Base value: " << baseValue << std::endl; }
protected:
int baseValue;
};
class Derived1 : public Base {
public:
Derived1(int val) : Base(val) {}
};
class Derived2 : public Base {
public:
Derived2(int val) : Base(val) {}
};
class Final : public Derived1, public Derived2 {
public:
Final(int val) : Derived1(val), Derived2(val) {}
};
int main() {
Final f(10);
f.show(); // 错误：二义性，不知道是Derived1还是Derived2中的show()
f.Derived1::show();
return 0;
}同时，多个父类继承于同一类时，会产生数据冗余。代码如下更改，derived1和derived2分别打印baseValue的地址，会发现两边的地址不同，即derived1和derived2继承的于Base的baseValue是分开的，可以得出结论——直接继承，在那条继承通道上会产生各自的继承副本，数据与其他继承通道是不共享的。
#include <iostream>
class Base {
public:
Base(int val) : baseValue(val) {}
void show() const { std::cout << "Base value: " << baseValue << std::endl; }
protected:
int baseValue;
};
class Derived1 : public Base {
public:
Derived1(int val) : Base(val) {}
void fun1()
{
printf("Derived1 baseValu: %p\n", &baseValue);
}
};
class Derived2 : public Base {
public:
Derived2(int val) : Base(val) {}
void fun1()
{
printf("Derived2 baseValu : %p\n", &baseValue);
}
};
class Final : public Derived1, public Derived2
{
public:
Final(int val) : Derived1(val), Derived2(val) {}
};
int main() {
Final f(10);
f.Derived1::fun1();
f.Derived2::fun1();
return 0;
}
这就是虚继承提出的必要性，虚继承解决了上述问题，确保无论有多少条路径继承自基类，派生类中只会有一个基类的实例。这样可以避免数据冗余和二义性问题。
#include <iostream>
class Base {
public:
Base(int val) : baseValue(val) {}
void show() const { std::cout << "Base value: " << baseValue << std::endl; }
protected:
int baseValue;
};
class Derived1 :virtual public Base
//class Derived1 : public Base
{
public:
Derived1(int val) : Base(val) {}
void fun1()
{
printf("Derived1 baseValu: %p\n", &baseValue);
}
};
class Derived2 :virtual public Base
//class Derived2 :public Base
{
public:
Derived2(int val) : Base(val) {}
void fun1()
{
printf("Derived2 baseValu : %p\n", &baseValue);
}
};
class Final : public Derived1, public Derived2
{
public:
Final(int val) : Derived1(val), Derived2(val),Base(val) {}
};
int main() {
Final f(10);
f.Derived1::fun1();
f.Derived2::fun1();
return 0;
}
普通继承的特点：
- 多份基类副本：如果一个类通过多个路径继承同一个基类，则每个路径都有一个独立的基类副本。
- 可能引起二义性：当试图访问基类的成员时，编译器无法确定使用哪个副本，从而导致二义性错误。
- 构造顺序简单：派生类构造函数直接调用其直接基类的构造函数。
虚继承的特点：
- 单一基类副本：无论通过多少条路径继承同一个基类，派生类中只会有一个基类的实例。
- 解决二义性问题：消除了由于多重继承引起的二义性问题。
- 复杂的构造顺序：需要显式调用虚基类的构造函数。通常，虚基类的构造函数应在最远派生类的初始化列表中被调用，而不是在中间基类中调用。
当然，直接继承与虚拟继承从实质上讲并不是说谁优谁劣，个人认为不排除需要有当你不需要共享基类实例，是可以使用普通继承的。
3、父类和子类有同名成员
父类和子类有同名成员时，这种情况子类会隐藏父类的成员。
class Base
{
public:
Base(int val)
:_val(val)
{
}
void getVal()
{
cout << "Base _val: " << _val << endl;
}
protected:
int _val;
};
class Derived1:public Base
{
public:
Derived1(int n)
:Base(n)
,_dval(n)
{
}
void getVal()
{
cout << "Derived _dval: " << _dval << endl;
}
protected:
int _dval;
};
int main()
{
Derived1 d1(1);
d1.getVal();
return 0;
}
其实隐藏是很好理解的，即就近原则，在Derived1中有getVal（）函数，则Derived1中的getVal（）函数是更加靠近d1的，所以会优先调用Derived1中的getVal（）。当然也可以指定调用Base中的getVal（）。
以上展示的是同名成员函数，同理同名成员变量也是同样的原理。
4、虚函数
谈到隐藏的时候就不得不提到虚函数。如果父类的函数是虚函数，子类中的同名函数会覆盖（而不是隐藏）父类的函数。父类指针或引用调用 show()，也会执行子类中的版本，这就是多态。这里不过多介绍多态。
class Base
{
public:
Base(int val)
:_val(val)
{
}
virtual void getVal()
{
cout << "Base _val: " << _val << endl;
}
protected:
int _val;
};
class Derived1:public Base
{
public:
Derived1(int n)
:Base(n)
,_dval(n+1)
{
}
virtual void getVal() override
{
cout << "Derived _dval: " << _dval << endl;
}
protected:
int _dval;
};
int main()
{
/*Derived1 d1(1);
d1.getVal();
d1.Base::getVal();*/
Base* b;
b = new Derived1(1);
b->getVal();
return 0;
}