C++对象模型剖析（六）一一Data语义学（二）

已于 2024-03-07 11:42:55 修改
阅读量1k 收藏 13
点赞数 22
分类专栏： 深度探索C++对象模型 文章标签： 开发语言 c++ unix
于 2024-03-01 12:35:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73170116/article/details/136392528
版权

Data 语义学（二）

“继承”与 Data Member

  • 只要继承不要多态（我认为这里翻译为 没有多态的继承 会更好一点）（Inheritance without Polymorphism）

    一般来说，继承带来的影响是 可以共享“数据本身”以及“数据的处理方法”，并将之局部化。（这里怎么理解这个局部化呢？我的理解就是，一般来说，一个类的成员变量都是私有的，但是类会提供访问这些成员变量的接口，这些接口是公开的，但一个类的继承了另一个类之后，派生类虽然在实际上拥有了基类的成员变量，但是逻辑上，派生类对基类成员变量的访问时受到接口的限制的，同时，每一个接口的作用范围都被限定在了声明该接口的类中，并不能对其他类的成员变量进行修改，这应该差不多就是这个意思了。）

    一般而言，具体继承（concrete inheritance，非虚拟继承）并不会增加空间或存取时间上的额外负担。

    下面来看看常见的两个错误：

    • 把原本独立不相干的 classes 凑成一对 “type/subtype”， 并带有继承关系。

      一些经验不足的人可能会重复设计一些相同操作的函数，（比如，constructor 或者 operator 之类的），它们并没有被做成 inline 函数。

    • 把一个 class 分解为两层或更多层，有可能会为了“表现 class 体系的抽象化” 而膨胀所需的空间。

      记住这一很重要的点：C++语言保证 “出现在 derived class 中的 base class object 有其完整性”。

      如何理解呢？我们看个例子吧。

      // 第一种实现
class test {
public:
    
private:
    int val;		// 4 btyes
    char c1;		// 1 btye
    char c2;		// 1 btye
    char c3;		// 1 byte
}

// 第二种实现
class test1 { private: int val; char c1; }
class test2 :public test1
{ private: char c2; }
class test3 : public test2
{ private: char c3; }

      我们在看看这两种实现最终的布局

      在这里插入图片描述

      这样，就能够很明显地看出来 从开始的 8字节的 class object 变成了 12 字节的 class object。

      那可能有会有人问了，之间把它们拼到一起不行吗？那我们在来看看（通过第二种实现来展示）

      在这里插入图片描述

      现在我们考虑一个场景：

      test1 t1 = new test1{};
test2 t2 = new test2{};
// 现在将t1拷贝到t2
t2 = t1;
// 这种情况下才用的是 bitwise copy，不了解的可以去看我的前几期的文章

      因为采用的 bitwise copy，所以编译器会将 test1 中的所有数据都拷贝到 test2 上，如果是前面的实现方式并不会出现问题，因为在那种布局下，class 与 class 中间是隔离的。但是，现在 test1 和 test2 都是 8字节，拷贝的时候也都是拷贝 8 字节，这就导致了 test1 的数据会覆盖 test2 中的数据，导致原本的 char c2 变成了无效数据了。

  • 加上多态（Adding Polymorphism）

    现在考虑这样一种情况，我们想要在一个继承体系中的不同的类中实现同一个接口，但是这个接口在不同的类中能够体现出不同的行为。比如：

    class Point2d { public: void func1(); private: int x, y; }
class Point3d : public Point2d
{ public: void func2(); private: int z; }

    在这种情况下，我们想要在 class Point2d和 class Point3d中通过一样的接口来对 point 进行操作，而不是像上面那样实现一个 func1() 和一个func2()。一种方法是通过重载的方法来实现，另一种是通过虚函数的方法来实现（virtual member function）

    // 方法一
class Point2d { public: void func1(int, int); private: int x, y; }
class Point3d : public Point3d
{ public: void func(int, int, int); private: int z; }

    算了，这里直接上点真的代码会更好一点

    class test {
public:
	auto _test(int i) -> void
	{
		std::cout << "this is _test(int)\n";
	}

private:

};

class test1 : public test {
public:
	auto _test(int i, int j) -> void
	{
		test::_test(1);
		std::cout << "this is _test(int, int)\n";
	}

private:
};


int main()
{
	test1 t{};
	t._test(1,1);
	test t1{};
	t1._test(1);
	return 0;
}

    看看输出

    在这里插入图片描述

    可以看到，跟上面一样，如果使用函数重载的话，在重载的函数中（也就是 Pointer3d::func()中）先调用 Point2d::func()进行二维处理，再处理三维的。其实使用虚函数的话也可以这样子做。

    现在看看如何用虚函数来实现这个功能吧。

    先看看例子是怎么实现的

    class Point2d { 
public: 
    virtual void func(); 
private: 
    int x, y; 
}
class Point3d : public Point2d
{ 
public: 
    virtual void func(); 
private: 
    int z; 
}

    再看看真正的代码，这里我就不跑了，大家也可以自己 copy 一下跑跑

    #if 1
#include <iostream>
class test {
public:
	virtual auto _test(int i) -> void
	{
		std::cout << "this is _test(int)\n";
	}

private:

};

class test1 : public test {
public:

#if 0
	// 第一种实现方法，跟之前的重载的方式差不多
	virtual auto _test(int i) -> void
	{
		test::_test(1);
		std::cout << "this is _test(int, int)\n";
	}
#else
	// 我们现在看看第二种吧
	// 这种的话是直接重写，不复用基类中的方法
	virtual auto _test(int i) -> void
	{
		std::cout << "this is _test(int)\n";
		std::cout << "this is _test(int, int)\n";
	}

#endif
private:
};

int main()
{
	test1 t{};
	t._test(1,1);
	test t1{};
	t1._test(1);
	return 0;
}
#endif

    但是大家注意到 重载 和 虚函数重写 的不同：函数重载需要重载的函数与原函数拥有不同的函数标签，但是 虚函数重写 它们的函数标签是相同的，只是实现不同。

    现在我们进入正题：

    我们引入了虚函数，这样无论我们是处理二维的点还是三维的点都可以直接调用同一的接口，这使我们的客户使用起来非常简便。这样也使我们的程序拥有了一定的弹性，这种弹性正是面向对象程序设计的核心。既然我们引入了虚函数，那么势必会给我们的 class 带来了额外的负担，究竟有什么负担呢？

    • 编译器需要导入一个虚函数表（virtual function table），用来存放该 class 所声明的每一个 virtual function 的地址。这个虚函数表元素的个数一般是被声明的虚函数的个数，再加上上一个或两个 slots （用来支持 runtime type identification）就是 type_info。
    • 在每一个 class object 中导入一个虚函数指针 vptr，提供一个执行期的链接，使每一个 object 能够找到相应的 virtual table
    • 加强 constructor，使它能够为 vptr 设定初值，让它指向 class 所对应的 virtual table。这可能意味着，在 derived class 和每一个 base class 的 constructor 中，重新设定 vptr 的值。
    • 加强 destructor，使它能够抹消 “指向 class 的相关 virtual table ” 的 vptr。vptr 很可能已经在 derived class destructor 中被设定为 derived class 的 virtual table 地址。记住，destructor 的调用顺序是反向的：从 derived class 到 base class。

    这些都是书上的原话，现在我们再看看作者对于 vptr 的放置的看法吧。

    • 放在 class 的开端。（现在流行的方法）。这种方式，对于 在多重继承之下，通过指向 class members 的指针调用 virtual function，会带来一些帮助。否则，不仅 “从 class object 起始点开始量起” 的偏移位置 （offset）必须在执行期就准备妥当，甚至与 class vptr 之间的 offset 也必须准备妥当。简单来说就是，在执行期，编译器会做多很多额外的工作。
    • 放在 class 的结尾。可以保留 base class struct c 的对象布局，因而允许在c程序中使用。

  • 多重继承（Virtual Inheritance）

    单一继承提供了一种“自然多态”（natural polymorphism）形式，是关于 classes 体系中的 base type 和 derived type 之间的转换关系。你会看到 base class 和 derived class 的objects 都是从相同的地址开始的，期间差异只在于 derived object 比较大，用以多容纳它自己的 nonstatic data members。

    Point3d p3d;
Point2d *p = &p3d;

    像上面一样，把一个 derived class object 指定给 base class 的指针或引用（reference）。这个操作并不需要编译器去调停或修改地址。所以它可以很自然地发生，而且提供了最佳的执行效率。

    但是，多重继承即不像单一继承，也不容易模塑出其模型。多继承的复杂度在于 derived class 和 其上一个 base class 乃至于上上一个 base class 之间的 “非自然”关系。

    看个例子

    class Point2d {
public:
    // 拥有virtual接口
private:
    float _x, _y;
};
class Point3d : public Point2d {
public:
    // ...
private:
    float _z;
}
class Vertex {
public:
    // 拥有virtual接口
private:
    Vertex *next;
};
class Vertex2d : public Point3d, public Vertex
{
public:
    //
protected:
    float mumble;
}
// 它们之间的继承关系
Point2d		Vertex
    |		  |
Point3d		  |
    |		  |
      Vertex3d

    **多重继承的主要问题发生在 派生类对象和它第二或后继的基类对象之间的转换。**不论是直接转换还是通过其所支持的virtual function 机制做转换。

    对于一个多重派生类对象，将其地址指定给第一个基类的指针，情况将和单一继承相同，因为它们都用相同的起始地址。但是，从第二个开始，就需要将地址进行修改（需要编译器进行）

    Vertex3d v3d;
Vertex *pv;
Point2d *p2d;
Point3d *p3d;

// 1.
pv = &v3d;
// 需要编译器在内部进行转换
pv = (Vertex*)(((char*)&v3d) + sizeof(Point3d));

// 2.
p2d = &v3d;
p3d = &v3d;
// 它们只需要简单地拷贝就行了。

// 3.
Vertex3d *pv3d;
Vertex *pv;
pv = pv3d;
// 不能够简单地被转化为
pv = (Vertex*)((char*)pv3d + sizeof(Point3d));
// 需要进行判空
pv = pv3d ? (Vertex*)((char*)pv3d + sizeof(Point3d)) : 0;

还剩最后一个 虚拟继承 ，因为内容有点多，需要时间梳理，所以明天在写了。

v3d;
p3d = &v3d;
// 它们只需要简单地拷贝就行了。

// 3.
Vertex3d pv3d;
Vertex pv;
pv = pv3d;
// 不能够简单地被转化为
pv = (Vertex)((char)pv3d + sizeof(Point3d));
// 需要进行判空
pv = pv3d ? (Vertex*)((char*)pv3d + sizeof(Point3d)) : 0;


还剩最后一个 虚拟继承 ，因为内容有点多，需要时间梳理，所以明天在写了。
alpha miao~
关注
  • 22
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++对象模型剖析（七）一一Data语义学（三）
m0_73170116的博客
03-02 975
一般的实现方法是这样的：**Class 如果内含一个或多个 virtual base class subobjects，像 istream 那样，将被分割成两部分，一个不变区域和一个共享区域。这样我们就能够很清楚的知道多重继承和虚拟继承的区别，而且我们也能看出在多重继承的体系下，我们需要维护两个 ios base class object ，这就造成了空间和效率上的浪费，我们不仅要为这两个 ios object 分配空间，我们还要同步对他们的修改操作，来保证两个 object 是一样的。
C++对象模型剖析（十）一一Function语义学（三）
m0_73170116的博客
03-06 1091
如果 vprt 被编译器放在 class 对象的开头处，这个字段就没有必要了，代价则是C对象兼容性降低，这些字段只在多重继承或虚拟继承的情况下才有必要，有许多编译器在自身内部根据不同的 classes 特性提供了多种指向 member functions 的指针的形式。换句话说，如果实际参数是一个常量表达式（constant expression），我们可以在替换之前先完成其求值操作，后继的inline替换，就可以把常量直接绑定上去，如果既不是常量表达式，也不是带有副作用的表达式，那么就直接替换。
C++对象模型剖析（五）一一 Data语义学（一）
m0_73170116的博客
03-01 1012
这时候，我们不能够说 pt 必然指向哪一种 class type（因此，在编译期，编译器无法确定这个 member 的真正的偏移位置 offset，所以 pt 的存取操作就会延至执行期，经由一个额外的间接引导，才能解决。比如 vptr，但是不同的编译器会将 vptr 放在不同的位置上，有的会将 vptr 放在 class object 的头部，有的则会将 vptr 放在 class object 的尾部。如果取一个 static data member 的地址，会得到一个指向其数据类型的指针。
C++对象模型剖析（十一）一一 构造、析构、拷贝语义学（一）
m0_73170116的博客
03-07 618
C++中保证在一个继承体系中的每一个 class object 的 destructor 都会被调用。并且编译器并会为一个类中的 pure virtual destructor 拓展其定义，所以，在设计一个类的时候，我们应该不要把virtual destructor 申明为 pure。我们再看一下。
C++对象模型剖析（九）一一Function语义学（二）
m0_73170116的博客
03-04 951
这一小节还是将的有点抽象的，我在后面的多继承那里卡了挺久的，有一些涉及到内嵌汇编的小东西，哈哈哈。
深入探索C++对象模型-Function语义学
MarksSa的博客
12-26 948
虚表的析构函数指向的实际上的Derived的析构函数，但是析构函数作为非静态成员函数会接受一个this指针作为参数，这个this指针指向的应当是Derived对象的起始内存地址，如果将pbase2将作为this指针传入，显然这个this指针是错误的，因此这个操作需要连带着this指针调整操作，而这个调整操作必须在执行期完成。同理的还有函数的重载机制，我们称两个函数拥有相同的函数名，但是拥有不同的参数数量和参数类型而能够同时存在的机制为重载，而实际上，这两个函数经过编译器处理都分别会有一个独一无二的函数名。
探究c++对象模型之data语义学（一）
aoumeior的博客
09-25 431
c++标准中有这样一个规定：   "no object shall have thesame address in memory as any other variable".   由此规定，导致几乎所有的编译器对一个空类都会添加一个char。   那什么是一个空类呢：   ·Has static members /member function   ·Has no vir
C++对象模型剖析（十二）一一构造、析构、拷贝语义学（二）
m0_73170116的博客
03-08 991
编译器在优化状态下可能会把object的连续内容拷贝到另一个object身上，而不会实现一个精确地“以成员为基础”的赋值操作。一般而言，如果一个类中有比较多的函数返回一个 local class object，那么为这个类设计一个拷贝构造函数是有必要的。一般而言，编译器会对类的每一个构造函数进行扩张，扩张的程度由类的继承体系而定。能够避免一个多余的无效操作，也能避免在拷贝的时候将原来的对象释放，造成悬空引用。书上还给出一个用例，给我们展示了编译器对类的扩充的结果，我们先来看看把。
C++对象模型剖析（十五）一一执行期语义学（一）
m0_73170116的博客
03-13 929
的函数，产生出以class object构造而成的数组。在比较新的编译器中，则是提供两个，一个用来处理没有virtual base class的class，另一个用来处理内含virtual base class 的class。如上所示，每当一个对象被定义的时候，编译器就会显式插入一个该对象的构造函数，当该对象所在的作用为即将结束的时候，编译器就会自动为它安插一个析构函数。并没有定义一个constructor或者一个destructor，那么我们的编译器确实是直接为其分配一个足够的空间即可。
深度探索C++对象模型 侯捷
Zy_05_11的博客
01-15 3239
目录 什么是C++对象模型 第一章 关于对象 1.1 C++对象模式 1.2 关键词所带来的差异 1.3 对象的差异 多态 指针的类型 第二章 构造函数语意学 2.1 Default Constructor的构造操作 2.2 拷贝构造器的构造操作 2.3 程序转化语意学 2.4 成员们的初始化队伍 第三章 Data语意学 3.1...
【三维语义分割】PointNet++ （二）：模型结构详解
叶子的博客
05-08 7205
PointNet++语义分割详细介绍，从S3DIS数据集处理到模型结构分析，以及代码运行等。 ​本节主要介绍PointNet++语义分割，其中主干网络和代码环境等PointNet++详细介绍请参考​​​​​​​三维目标分类 — PointNet++详解（二）_Coding的叶子的博客-CSDN博客，这里不再进行重复介绍。 1 代码环境部署 请参考​​​​​​​三维目标分类 — PointNet详解（一）_Coding的叶子的博客-CSDN博客。 2 数据介绍 ...
LLM 大模型学习必知必会系列(十一)：大模型自动评估理论和实战以及大模型评估框架详解
丨汀、的博客
05-24 1084
LLM 大模型学习必知必会系列(十一)：大模型自动评估理论和实战以及大模型评估框架详解
10.9：C++移动语义的性能和效率分析！（课程共6350字，2个代码举例）
小兔子平安
07-28 30
总体而言，本课程对C++移动语义的基本概念、语法和实现方式进行了详细的介绍和解析，并探讨了移动语义在程序性能和可维护性方面的优势和应用。通过本课程的学习，我们可以深入理解C++语言中移动语义的原理和实现方式，掌握如何使用移动语义来提高程序的性能和可维护性，以及避免常见的编程错误和陷阱。
⭐⭐⭐⭐⭐Linux C++性能优化秘籍：从编译器到代码，探究高性能C++程序的实现之道
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-06 1875
高性能C++编程涉及多个方面，包括编译器优化、C++代码性能优化基本原则、C++对象管理与性能优化、多线程编程与性能优化、Linux系统调用优化等。通过学习和掌握这些要点，程序员可以有效地提高C++程序在Linux环境下的性能。接下来的章节将对这些核心要点进行详细的介绍。
一个php快速项目搭建框架源码，带一键CURD等功能
jiyc2008的博客
08-26 5899
框架易于功能扩展，代码维护，方便二次开发，帮助开发者简单高效降低二次开发成本，满足专注业务深度开发的需求。百度网盘下载。
【C++】STL—vector的使用
2301_77112794的博客
09-04 668
本文介绍了vector重点函数接口的使用
C语言操作符详解1（含进制转换，原反补码）
hdxbufcbjuhg的博客
09-02 1370
左移操作符对一个十进制整数的影响是有规律的，无论正负数，都可以对原数值起到乘以2的移位次方的作用，比如将10左移了1位，那么就对原数值乘以了2的一次方，变成了20，依次类推，如果是-10左移了1位，那么就会变成-20对一个无符号数进行右移操作，会对它进行除以2的移位次方，比如将10右移一位，就对它除以了2的一次方，最后变成了5，那如果这个数不是偶数怎么办呢？比如123向右移一位，它除以2就是61.5，最后结果会返回这个数两边较小的整数，61.5的两边分别是61和62，最终得到小的那个数61，所以综上，
C语言 | Leetcode C语言题解之第389题找不同
最新发布
m0_59237910的博客
09-07 406
C语言 | Leetcode C语言题解之第389题找不同
C++对象模型深度解析：构造、继承与底层机制详解
《深入探索C++对象模型》是一本由侯捷翻译，由Lippman编写的经典著作，该书深入剖析了C++面向对象程序设计的底层机制。作者作为C++编译程序cfront的设计者，以其丰富的经验和独特的视角，解析了C++中的explicit...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值