c++对象模型之对象

已于 2023-09-10 23:00:55 修改
阅读量97 收藏
点赞数 1
分类专栏： c++对象模型 文章标签： c++
于 2023-09-10 01:29:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dfadfsdfs/article/details/132783506
版权

参考：c++新经典对象模型，王建伟编著

1.类对象所占用的空间

1.1 空类对象大小为1

class A
{
public:
};
int main()
{
    A a;
    int ilen = sizeof(a); // res: ilen=1
}

对象是有地址的，即便是一个空类的对象，因为在内存中是有起始地址，既然这个地址属于该对象，该对象必然最少能存的下一个字节。

1.2 类中的成员函数不占类对象内存空间

总结：

1.成员变量是包含在每个对象中的，占字节的

2.成员函数写在类定义中，但成员函数不占类对象字节空间。

2.c++对象模型简介

类对象大小：非静态成员变量+虚函数表指针，  静态变量+成员函数与类对象无关

  1. 非静态的成员变量跟着对象走

  2. 静态成员变量与对象无关，不计算在sizeof内

  3. 成员函数，不管静态与非静态，都保存在对象之外，不计算在sizeof内

  4. 虚函数不计算在对象的sizeof内，虚函数让类对象多了一个4字节的虚函数表指针

  5. 虚函数表是基于类的，不是基于对象的

一个类有一个虚函数，就会产生一个指向虚函数的指针，有两个虚函数，则会有两个指向虚函数的指针，这些指向虚函数的指针，都会放在虚函数表里，同时，类对象会有一个指向虚函数表的虚函数表指针。

类的对象要调用类的虚函数时，实际是通过虚函数表指针找到类的虚函数表，这是“多态”的实现的原理

总结：

类对象大小的组成：

1.非静态成员变量所占内存 + 字节对齐占用内存

2.虚函数表指针（如果类有虚函数的话）

3.this指针调整

this指针发生在多重继承下

两个基类A,B ， 一个派生类C，不存在同名函数覆盖的情况

代码示例：

#include<iostream>
class A{
public:
    int a;
    A()
    {
        std::cout << "A::A() this=" << this <<std::endl;
    }
    void funA()
    {
        std::cout << "A::funA() this=" << this <<std::endl;
    }

};

class B{
public:
    int b;
    B()
    {
        std::cout << "B::B() this=" << this <<std::endl;
    }
    void funB()
    {
        std::cout << "B::funB() this=" << this <<std::endl;
    }

};

class C: public A, public B{
public:
    int c;
    C()
    {
        std::cout << "C::C() this=" << this <<std::endl;
    }
    void funC()
    {
        std::cout << "C::funC() this=" << this <<std::endl;
    }

};

int main()
{
    C oc;
    oc.funA();
    oc.funB();
    oc.funC();
    
};

//output
A::A() this=0x7ffee29a0420
B::B() this=0x7ffee29a0424
C::C() this=0x7ffee29a0420
A::funA() this=0x7ffee29a0420
B::funB() this=0x7ffee29a0424
C::funC() this=0x7ffee29a0420

前三行输出：A构造函数的this指针与B构造函数指针不同，相差4字节， 基类A构造函数的this指针与派生类C构造函数的this指针相同。

后三行输出：执行funcB时，this指针从原来的0x7ffee29a0420变为0x7ffee29a0424，属于编译自内部自动调整this指针

总结：

1.如果派生类只继承一个父类，则派生类对象地址与基类子对象地址相同

2.如果派生类继承多个父类，则第一个继承的基类的子对象地址与派生类对象起始地址相同，后续的基类子对象的起始地址与派生类对象起始地址相差前面基类子对象所占用的内存空间。注意：继承顺序很重要，例如class C: public A, public B，C的this与A的this相同.

C类覆盖B类的同名函数funcB：

#include<iostream>
class A{
public:
    int a;
    A()
    {
        std::cout << "A::A() this=" << this <<std::endl;
    }
    void funA()
    {
        std::cout << "A::funA() this=" << this <<std::endl;
    }

};

class B{
public:
    int b;
    B()
    {
        std::cout << "B::B() this=" << this <<std::endl;
    }
    void funB()
    {
        std::cout << "B::funB() this=" << this <<std::endl;
    }

};

class C: public A, public B{
public:
    int c;
    C()
    {
        std::cout << "C::C() this=" << this <<std::endl;
    }
    void funB()
    {
        std::cout << "C::funB() this=" << this <<std::endl;
    }
    void funC()
    {
        std::cout << "C::funC() this=" << this <<std::endl;
    }


};

int main()
{
    C oc;
    oc.funA();
    oc.funB();
    oc.funC();
    oc.B::funB();
    
};

//output
A::A() this=0x7ffc5d1108a0
B::B() this=0x7ffc5d1108a4
C::C() this=0x7ffc5d1108a0
A::funA() this=0x7ffc5d1108a0
C::funB() this=0x7ffc5d1108a0
C::funC() this=0x7ffc5d1108a0
B::funB() this=0x7ffc5d1108a4

第五行：C::funB() this=0x7ffc5d1108a0

总结：

调用哪个子类的成员函数，这个this指针就会被编译器自动调整到对象内存布局中对应该子类的起始地址那去

4.编译器生成合成默认构造函数时机

当程序员没有定义任何构造函数时，不要想当然编译器会隐式的自动合成默认构造函数，只有在必要的时候才会去生成合成默认构造函数。

时机1：

1.如果该类A没有任何构造函数

2.该类A包含一个类类型B的成员变量

3.B类型有一个默认构造函数

编译器生成合成默认构造函数的目的：在合成默认构造函数中安插代码来调用类B的默认构造函数

时机2：

1.父类有默认构造函数

2.子类没有任何构造函数

当创建一个子类对象时，父类的这个默认构造函数是要被调用的，所以编译器生成合成默认构造函数，用来安插代码来调用类B的默认构造函数

时机3：

1.一个类有虚函数

2.该类没有任何构造函数

编译器生成合成默认构造函数的目的：因为虚函数的存在，编译器会为该类生成一个虚函数表，所以会自动生成合成默认构造函数，在其中安插代码来对虚函数表指针赋值，虚函数表值相当于一个隐藏的成员变量

理解：

如果程序员编写了自己的默认构造函数时，编译器会根据需要扩充该构造函数，向其中安插必要代码：1.加入调用父类的构造函数代码   2.加入给虚函数表指针赋值的代码

时机4：

1.一个类有虚基类，编译器也会为生成一个“合成默认构造函数”

编译器生成合成默认构造函数的目的：在合成默认构造函数中安插代码给虚基类表指针赋值以及调用父类的构造函数，

虚基类构成条件：三层结构，爷爷类Grand，两个父类A和A2， 一个孙子类C，Grand是C的虚基类。

虚基类解决的问题：基类对象Grand在孙子类C中被继承两次，解决名字冲突问题。

时机5：

1.如果在定义成员变量的时候赋初值，c++11新语法

class A{
public:
    int bb{0};  //定义并初始化成员变量
}；

编译器生成合成默认构造函数的目的：在合成默认构造函数中安插代码，初始化bb成员变量的值为0(因为代码中{}给的初值为0)

5.编译器生成拷贝构造函数的时机

当类A只有简单类型的成员变量或者A的成员变量为类类型B，B中只有简单类型变量，这种情况下：

编译器手法：直接就按值拷贝过来了，不需要合成拷贝构造函数。如果只一些类成员变量的值复制这些简单的事情，编译器不用专门生成拷贝构造函数

时机1：

1.如果类A没有拷贝构造函数

2.该类A有一个类类型B成员变量，类 B有拷贝构造函数

编译器生成拷贝构造函数目的：向其中插入代码，从而调用类B的拷贝构造函数

时机2:

1.类A没有拷贝构造函数，但他有个父类B

2.父类B有拷贝构造函数

编译器生成拷贝构造函数目的：生成类A的拷贝构造函数，在该函数内插入调用父类B的拷贝构造函数。

时机3:

1.如果类A没有拷贝构造函数

2.类A定义了虚函数或者类A 的父类定义了虚函数

编译器生成拷贝构造函数目的：生成类A的拷贝构造函数，在该函数内插入代码来给被复制的对象的虚函数表指针赋值。

时机4：

1.如果一个类A没有拷贝构造函数

2.但是该类A有虚基类

编译器生成拷贝构造函数的目的：在拷贝构造函数中安插代码给虚基类表指针赋值以及调用父类的拷贝构造函数

6.编译器生成移动构造函数的时机

不生成时机

如果一个类A定义了自己的拷贝构造函数、拷贝赋值运算符、或者析构函数（任意一个），表示：程序员要自己处理对象的复制或者释放问题，则编译器不会生成该类的移动构造函数和移动复制运算符。

生成时机

类A没定义任何自己版本的拷贝构造函数、拷贝赋值运算符、析构函数，且类的每个非静态成员都可以移动时，编译器才会自动合成移动构造函数和移动复制运算符。

成员可以移动

1.内置类型的成员变量可以移动

2.如果成员变量是一个类类型，如果这个类有对应的移动操作相关的函数，则该成员变量可以移动

7.程序员视角vs编译器视角

1.定义时初始化对象


#include<iostream>
class A{
public:
int m_i;
A(){ std::cout<<"A::()";}
A(const A& a){ m_i = a.m_i;}
};

int main()
{
    A a0;
    A a1 = a0;  
}

程序员视角：

A a11=a0;  调用A的拷贝构造函数

编译器视角：

1.定义一个对象，为其分配内存，不会调用构造函数。

A a11;

2.直接调用对象的拷贝构造函数

a11.A::A(a0)

没有显示调用构造函数或者拷贝构造函数的代码，编译器是不会自动去调用构造函数或者拷贝构造函数的

2.参数的初始化


#include<iostream>
class A{
public:
int m_i;
A(){ std::cout<<"A::()";}
A(const A& a){ m_i = a.m_i;}
};

void func(A tmpa)
{
    return;
}

int main()
{
    A a0;
   func(a0);
}

程序员视角：

func(a0);  //形参调用拷贝构造函数，函数返回后调用析构函数

编译器视角：

编译器在func的函数空间内构造tmpa对象，然后func函数返回前，再把tmpa对象析构掉

A tmpobj;

tmpobj.A::A(a0);

func(tmpobj);  //func(A &tmpa); 函数类型会变为引用类型

tmpobj.A::~A()

3.返回值初始化


#include<iostream>
class A{
public:
int m_i;
A(){ std::cout<<"A::()";}
A(const A& a){ m_i = a.m_i;}
};

A func()
{
    A a;
    return a;
 
}

int main()
{
    A my = func();
}

程序员视角：

因为return a; 产生了临时对象，这个临时对象直接构造到了my中，可以把my当成临时对象

编译器视角：

void func(A& tmp){

A a;

tmp.A::A(a);

return;

}


int main(){
A my;  //这里编译器只是创建内存空间，不调用构造函数
func(my);

}

新增一个成员函数 A::functest()

程序员视角：

func.functest();

编译器视角：

X my;

(func(my), my).functest(); //逗号表达式，表达式的值为表达式2的值

8.临时对象优化

CTemp TEST(CTemp &tt)
{
CTemp tmp; // 这里消耗一个构造函数和一个析构函数
tmp.a = tt.a;
tmp.b = tt.b;
return tmp; //这里调用了拷贝构造函数和析构函数，表示生成了临时对象。
}

int main(){
CTemp ts(1,2);  //一次构造函数和一次析构函数
TEST(ts);        //临时对象没有接收者
}

临时对象没有接收者：

TEST函数返回的临时对象return tmp；没有接收者，所以这个临时对象在TEST函数调用后被立即释放掉

临时对象有接收者：

CTmp a = TEST(ts);

TEST返回的临时对象不会被立即释放掉，而是直接构造到a中，并且一直到a的作用域结束后才会析构该临时对象

函数返回return优化：

程序员视角优化：

CTemp TEST(CTemp &tt)
{

return CTemp(tt.a, tt.b); //临时对象
}

编译器视角优化：

void TEST(CTemp &a, CTemp &tt) /编译器插入一个参数a
{
a.CTemp::CTemp(tt.a, tt.b);
return;
}

ROV(return value optimizaiton) 编译器针对临时变量的优化

9.成员初始化列表

必须使用成员初始化列表场景：

1.成员变量是引用类型

2.成员变量是const类型

3.该类继承一个基类，并且基类中有构造函数，这个构造函数有参数

4.成员变量是类类型，且，这个类类型的构造函数有参数

李阳不在服务区
关注
专栏目录
c++对象模型探索-王健伟-专题视频课程
KuangXiang的专栏
10-12 4392
c++对象模型知识久负盛名，在c++界具有很高的美誉度，这方面知识的学习，更是被诸多颇具开发实力的行业前辈倾力推荐！ 本门课程内容将涉及到很多不被常人所知的 c++对象内部工作原理、底层的一些具体实现机制方面的知识，本门课程属于“提高个人c++开发修养，练习c++编程内功的一门课程”，课程定位为"c++大师进阶级"课程。...
C++ 对象模型
12-08
详细介绍C++ 对象模型， 对象内存布局
C++::探索对象模型
qq_41027326的博客
07-19 217
前面我们已经知道, 在没有虚函数的时候, 对象的大小就是对应的成员变量的大小, 而成员函数不会占用对象的空间, 今天我们来讨论一下, 当类中定义了虚函数的时候, 此时对象的大小以及对象模型 非继承下的对象模型 class Base { public: virtual void func1() { cout &lt;&lt; "Base::func1()" &...
图解 C++ 对象模型，看这一篇就够了！
luoyayun361的专栏
02-02 1652
《深度探索C++对象模型》这本书对对象模型的描述如下：语言中直接支持面向对象程序设计的部分，包括了构造函数、析构函数、多态、虚函数等等。对象模型的底层实现机制并未标准化，不同编译器有一定的自由来设计对象模型的实现细节。在我看来，对象模型研究的是对象在存储上的空间和时间上的更优，并对C++面向对象技术加以支持，如以虚指针、虚表机制支持多态特性。C++中虚函数的作用主要是为了实现多态机制。多态，简单来说，是指在继承层次中，父类的指针可以具有多种形态—当它指向某个子类对象时，通过它能够调用到子类的函数，而非父类的
《C++新经典对象模型》之第6章 对象构造语义学
最新发布
yxqq378287007的博客
03-19 1126
（2）在构造函数中调用的虚函数从所在类往根类回溯，逐次找这个虚函数，找到哪个就直接调用（静态方式）。（2）类中类类型成员变量具有析构函数，会在析构函数后面插入代码，调用该成员变量所属类的析构函数。（1）构造函数中调用虚函数，并不通过虚函数表来调用，而是直接调用（虚函数有真实地址）。（1）类继承的父类具有析构函数，会在析构函数后面插入代码，调用父类的析构函数。先成员变量（定义顺序，从上到下），后构造函数（先初始化列表，后函数体）。（1）类继承的父类具有析构函数，会合成析构函数并调用父类的析构函数。
深度探索c++对象模型(2012版本)
02-07
《深度探索C++对象模型》是一本专注于C++底层机制的专著，主要针对2012年的标准进行深入解析。C++是一种多范式、静态类型、编译型、并发型、通用程序设计语言，它以其强大的功能和灵活性而闻名。这本书的目标是帮助...
C++对象内存模型.pdf
04-18
这个模型是 C++ 编程语言的基础之一，对于理解 C++ 编程语言的工作机理具有重要的意义。 在 C++ 中，对象的内存模型是根据类的定义来确定的。类的定义包括了类的成员变量和成员函数，这些成员变量和成员函数在内存...
深度探索C++对象模型 超高清pdf
01-12
深度探索C++对象模型 超高清
深度探索C++对象模型 PDF中文清晰版
10-20
《深度探索C++对象模型》是一本面向有C语言基础的读者，旨在深入解析C++这一强大编程语言中关于对象模型的专著。C++作为面向对象编程的典范，其对象模型是理解语言特性和底层机制的关键。这本书的中文清晰版提供了一...
C++对象模型
07-30
C++模型之菱形虚拟继承中的内存分布
《C++新经典对象模型》之第1章 演示环境介绍和准备
yxqq378287007的博客
03-05 321
1.1 演示环境搭建1.2 基本C++程序1.3 Visual Studio中调试方法。
C++高级课程
10-11
C++对象模型知识久负盛名，在C++界具有很高的美誉度，这方面知识的学习，更是被诸多颇具开发实力的行业前辈倾力推荐！该门C++对象模型探索课程内容将涉及到很多不被常人所知的 C++对象内部工作原理、底层的一些具体实现机制方面的知识，本门课程属于“提高个人C++开发修养，练习C++编程内功的一门课程”，课程定位为C++大师进阶级课程。C++对象模型知识相对于C++基础知识属于高端知识范畴，而相对于C++高端知识（比如设计模式、模板与泛型编程等），又属于高端中的基础知识，认真学好，将对后面学习设计模式、模板与泛型编程等打下坚实的基础，让你少走很多弯路节约大量时间。
《深入探索C++对象模型》之一
杨林峰的笔记
04-26 8532
前言：        由于经常使用C++，但是又对C++内部机制不是很深入了解，所以看了一些关于C++的经典书籍，其中有《C++ Primer》、《STL源码剖析》、《Efficitive C++》、《More Efficitive C++》。《C++ Primer》特别适合刚使用C++的程序员学习，里面详细介绍了一些C++基础知识，包括流和STL容器、适配器、算法还有C++的面向对象的一些知识。...
c++对象模型
copymaster
01-02 1506
关于对象 加上封装后的布局成本 c语言中如下声明一个结构体 typedef struct point3d{ float x; float y; float z;}Point3d; struct point3d 转化为class Point3d之后 class Point3d { public: Point3d(float x = 0.0f, float y = 0.0f; f...
C++::几道关于对象模型的经典题
海绵宝宝的欧尼~ 的博客
12-18 722
1、我们先来看第一道： #include using namespace std; class A { public: A() { m_a = 1; m_b = 2; } void fun() { cout<<m_a<<" "<<m_b<<endl; } private: int m_a; int m_b; }; class B { public: B() {
C++对象模型和布局（三种经典类对象内存布局）
净无邪博客
12-31 1099
侯捷翻译的《深度探索C++对象模型》一书中，对C++对象模型进行了三种典型模型划分，分别为简单对象模型（A Simple Object Model）、表格驱动对象模型（A Table-drive Object Model）、C++对象模型（The C++ Object、 Model）。本文以及之后的博客主要总结的都是最后一个C++对象模型。在C++中，成员分为成员变量和成员函数，其中成员变量分别静态成员变量（class static data members）、非静态成员变量（class nonstati
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值