C++相关概念和易错语法(20)(赋值兼容转换、多继承、继承与组合)
1.赋值兼容转换
赋值兼容转换有一点易混,先看一下下面的代码,想想a、b、c对象里面存的什么,顺便结合以前的知识,对继承加深理解。
#include <iostream>
using namespace std;
class A
{
protected:
A(int a)
:_a(a)
{}
int _a;
};
class B : public A
{
public:
B(int a, int b)
:A(a)
,_b(b)
{}
int _b;
};
int main()
{
B b(1, 2);
A a = b;
A c(0);
return 0;
}
结果如下,其中A c(0)操作不合语法,报错
(1)为什么A c(0)报错?
A的构造函数是protected,对外和private没有任何区别,都是无法访问的,因此在main函数里创建对象无论如何都是不会成功的,因为调不到private构造函数,也不会生成一个默认构造(因为已经有了一个构造函数)
(2)为什么B b(1, 2)操作可行?
B以public继承A的protected函数意味着B能访问A的protected函数,该函数在B中的访问限制为protected,所以在B中是可以调用A的构造函数的,能完成变量的初始化。这里有点难理解,属于继承中比较绕的部分了
(3)A a = b是什么操作?
这涉及一个新的概念:赋值兼容转换。这是子类给父类赋值的一种操作。在这里b是子类对象,a是父类对象。子类可给父类赋值,相当于将子类中的父类继承给它的那部分数据赋值给它。我们还可以使用父类指针或引用,指针就是指向子类的父类部分,当修改父类指针的指向内容时,子类的内容也被修改了。引用也是指向子类的父类部分,相当于给子类的父类部分取别名。
赋值兼容转换类似于将子类切出一部分给父类,所以这个过程又叫切割或切片。
(4)区分赋值兼容转换和隐式类型转换
最本质的区别在于两者的底层操作不同。对于赋值兼容转换来说,无论是赋值、指针、引用,都不会在中间生成临时变量,赋值就是截断后将子类数据拷贝给父类,指针和引用都是直接让父类指向子类对应部分的。而变量隐式类型转换会先用一个临时变量存储类型提升、截断后的数据,再将这个数据赋值回去,这个临时变量的有无是区分两者的关键。
对于赋值兼容转换来说,没有临时变量意味着当父类引用时不会出现权限缩小的情况,即我们可以通过父类引用修改子类的值。
而对于其他变量来说,只要左右数据类型不同就会发生隐式类型转换,中间会产生临时变量,这个变量是常属性的,会导致必须加const才能引用
(5)赋值兼容转换注意事项
a.赋值兼容转换是一个单独的语法规则,和隐式类型转换没有任何关系,前面已经很充分的分析了
b.赋值兼容转换只能在public继承方式下可用
只要继承不是public,无论访问限定符是什么,都不行
c.赋值兼容转换可以跨级
但必须保证子赋值给父,中间继承方式只能是public
2.拷贝构造
看一下下面的代码,尝试理解继承下的拷贝构造
#include <iostream>
using namespace std;
class A
{
public:
A() = default;
A(const A& a)
:_a(new int[10])
{
for (int count = 0; count < 10; count++)
{
_a[count] = a._a[count];
}
}
int* _a = new int[10] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
};
class B : public A
{
public:
B() = default;
B(const B& b)
:A(b)
,_b(new int[10])
{
for (int count = 0; count < 10; count++)
{
_b[count] = b._b[count];
}
}
int* _b = new int[10];
};
int main()
{
B b1;
B b2 = b1;
b1._a[0] = 1, b2._a[0] = 2;
b1._b[0] = 3, b2._b[0] = 4;
return 0;
}
继承下的六大成员函数都和普通类的成员函数大差不差,只要不显式写,都是默认调用父类的对应的默认成员函数,所以我们需要注意的就是当遇到深拷贝时要会显式地去写拷贝构造
其中特别注意子类的拷贝构造利用了赋值兼容转换,需要着重理解
3.多继承
(1)多继承理解
C++支持多继承,即一个子类继承多个父类,享有多个父类的成员函数和成员变量。在语法上只需要用逗号隔开,分别写继承方式和继承的父类,在特性上和单继承基本上没区别,前面理解了这里就非常简单。
(2)菱形继承
这是在谈到多继承时不得不面对的问题——菱形继承。我们刚刚理解多继承觉得没啥问题,不就是单继承的翻版吗?但下面这种情况就有问题了。
我们会发现,BCD都没有问题,但E就有问题了,E通过两条继承关系链继承了两次A,意味着E里面有两份A的成员变量,这是单继承永远碰不到的情况,这叫数据冗余。
在数据冗余的前提下,E想要初始化或者访问A继承下来的成员变量时,也不知道到底要访问哪一份,这叫做二义性。
(3)二义性
观察下面的代码,看看如何消除二义性。
#include <iostream>
using namespace std;
class A
{
public:
int _a;
};
class B : public A
{};
class C : public B
{};
class D : public A
{};
class E : public C, public D
{};
int main()
{
E e;
e.D::_a = 1, e.C::_a = 2;
cout << e.D::_a << " " << e.B::_a << endl;
return 0;
}
执行结果
我们发现,只有E会产生二义性,而BC和D分别对应的A是唯一的,由于E同时继承了BCD,我们只需要在BCD中访问_a就可以避免歧义,即确定类域。
(4)数据冗余和虚拟继承
二义性解决了,但数据冗余仍然存在。事实上,我们发现当B和D出现的时候,数据冗余就已经无法避免了
所以源头是在B和D身上,我们是否可以使用一种办法,让B和D中的A实际上只有一份呢,这就要使用到virtual,即虚拟继承。
我们先看看在刚才代码的基础上给B和D使用虚拟继承后会发生什么?
#include <iostream>
using namespace std;
class A
{
public:
int _a;
};
class B : virtual public A
{};
class C : public B
{};
class D : virtual public A
{};
class E : public C, public D
{};
int main()
{
E e;
e.D::_a = 1, e.C::_a = 2;
cout << e.D::_a << " " << e.B::_a << endl;
return 0;
}
结果是
可以看到,当使用虚拟继承后,BD共享一个A,即整个继承体系中只有一份A,这就避免了数据冗余的情况。
在实际情况中,我们应当慎重使用多继承,一定要提防菱形继承,尽量不要使用,就算我们有菱形虚拟继承来解决这个问题。在很多语言中都没有多继承这个概念了,就是因为菱形继承带来的很多冗杂的语法处理和理解难度。
4.继承与组合
(1)继承和组合的区分和选择问题
继承上面已经讲了很多,不再重复。组合就是在一个类里使用另一个类作为它的成员变量,这种写法之前我们见过很多次了,在很多语法讲解上都使用了组合。我们现在需要思考:组合和继承的区别是什么?在两者之间怎样选择?
组合和继承的本质都是复用。继承语法中父子的关系通常是:子是父,子是父属性的一种延伸;
而组合通常是:A的组成中含有B,A的组成中含有C。继承是is关系,组合是has关系。
在选择过程中,如果两者表现出强is关系,那就使用继承,如植物和水果,动物与人。如果表现出强has关系,就使用组合,如汽车和汽油,自行车和轮胎。如果呈现两者均可的关系(如stack含有vector,stack就是vector),那么就优先使用组合。
(2)黑箱复用和白箱复用
继承作为面向对象编程三大特性之一,为什么反而推荐优先使用组合呢?这需要涉及黑箱白箱(黑盒白盒)的概念。
继承本质上是一种白箱复用,而组合是黑箱复用。
黑箱是不可见的,就像当我们使用组合时,被使用的类的细节我们是不知道的,但我们会用,如STL很少有人能讲清楚里面的细节。当使用黑箱复用时,我们关注的是这个类的功能,有什么接口,这是非常容易学习的。不仅如此,黑箱复用还将封装的特性完美展示了出来,我们只能调用该类向外展示的函数接口,其余细节完全不知道,因此如果这个类出现了毛病,有人去维护,它们只需要修bug就行了,只需要保证对外提供的接口是安全的,功能是正常的就可以了。
白箱复用是可见的,就像当我们使用继承时,父类除private以外其余的成员我们都可以直接调用。我们书写的代码是嵌在父类上的,这种模式下封装的特性就明显被弱化了。父类中的protected成员对外不开放但对子开放,就会导致当父类出现毛病时,有人去修改时,如果动了protected成员函数,那么子类的代码会立马失效,而一般来讲,protected成员更倾向于类功能的底层,函数更多,父类的书写者不可能去考虑子类调用的情况来适配,这对于书写子类功能的人来说无疑是一场灾难。这也是高内聚(函数功能集中),低耦合(类与类之间的关系不紧密)的反面教材。
白盒测试和黑盒测试也遵循上面的规则。黑盒测试注重对功能,接口的测试;而白盒测试注重于观察底层代码细节,从源码入手测试。白盒测试相比较黑盒测试更轻松。
综上,我们可以充分理解为什么推荐组合而不是继承。总的来说继承是以牺牲一定封装特性换来的,而随着我们深入学习,我们会意识到,封装才是编程思想的老大,任何破坏封装特性的行为都要深思熟虑。当然,如果确实存在强is关系时,继承依然可靠。
原文地址:https://blog.csdn.net/SGlow0708/article/details/140389521
免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!