c++ 对象内存分配和虚函数

最新推荐文章于 2022-08-02 11:35:45 发布
最新推荐文章于 2022-08-02 11:35:45 发布
阅读量113 收藏
点赞数
文章标签： c/c++
1. c++类对象(不含虚函数）在内存中的分布

    c++类中有四种成员：静态数据、非静态数据、静态函数、非静态函数。 
1. 非静态数据成员放在每个对象内部，作为对象专有的数据成员 
2. 静态数据成员被抽取出来放在程序的静态数据区内，为该类所有对象共享，只保留一份 
3. 非静态成员函数和静态成员函数最终都被提取出来放在程序的代码段中并为该类所有对象共享，因此每个成员函数也只能存在一份代码实体。

    因此，构成对象的只有数据，任何成员函数都不属于任何一个对象，非静态成员函数和对象的关系就像是绑定，绑定的中介就是this指针。 
1. 不含有虚函数的对象在内存中分配 
    如下代码示例：

class Test3{
public:
	void f(){
		cout << "f in Test3" << endl;
	}
	static int a;
};
class Test4{
public:
	void f(){
		cout << "f in Test4" << endl;
	}
	int a;
};

class Test5{
public:
	void f(){
		cout << "f in Test5" << endl;
	}
	int a;
	char c;
};
struct Test6{
	char c[];
};
int main(){
	Test3 test3;
	cout << "size of Test3 = " << sizeof(Test3) << endl;    //1, 不含有非静态数据
	cout << "size of test3 = " << sizeof(test3) << endl;    //1

	Test4 test4;
	cout << "size  of Test4 = " << sizeof(Test4) << endl;   //4 含有非静态数据int
	cout << "size  of test4 = " << sizeof(test4) << endl;   //4

	cout << "size  of Test5 = " << sizeof(Test5) << endl;   //8，含有非静态数据 int和char
	//这里为8，显然是int 和 char对齐之后的结果。
	
	cout << "size  of Test6 = " << sizeof(Test6) << endl;   //1，结构体或类中，空数组，大小为1
	return 0;
}

 

    从以上的代码示例中可以看出，类的对象（不含有虚函数）的size值等于对象中所有非静态成员对齐后的size之和。对齐规则同结构体，详见 结构体对齐. 
    同时也有，若结构体或类中不含有任何数据，sizeof结果为1；若结构体或类中只有空数组，不占用空间，sizeof结果仍为1；若结构体或类含有数据，最后添加了空数组，空数组不占空间，sizeof为去掉空数组之后的对齐后大小.

    那么，如果知道了对象在内存中的地址，就可以得到各个非静态成员的地址，然后可以强行修改，如：

    Test3 test4;
    int* p = (int*)&test4;
    *p = 200; //此时test4对象内部的a值就被修改了

 

但这种方式很不安全，强烈不推荐！

2. 虚函数

    c++中通过虚函数来实现运行时多态，主要方法如下：

    编译器对每个包含虚函数的类创建一个表（称为 VTABLE，虚函数表），在VTABLE中，编译器放置特定类的虚函数地址。在每个带有虚函数的类对象中，编译器秘密的内置一个指针，称为 vpointer(VPTR)，指向这个对象的VTABLE。通过基类指针做虚函数调用时（也就是做多态调用时），编译器静态的插入取得这个VPTR，并在VTABLE表中查找函数地址的代码，这样就能够调用正确的函数使晚捆绑发生。 
    为每个类设置VTABLE，初始化VPTR，为虚函数插入调用代码，所有这些都是自动发生的。利用虚函数，这个对象的合适的函数就能被调用，哪怕在编译器还不知道这个对象的特定类型的情况下。（《c++编程思想》）

3. 虚函数表在内存中分布

    对于有虚函数的基类和子类来说，内存中类对象的开始位置就是4字节的VPTR（虚函数表的地址，指向VTABLE）。如果一个子类继承自基类，且没有对虚函数进行重写，子类仍然会自己维护一个虚函数表，和基类的虚函数表地址不同（尽管可能内容相同）。 
    虚函数表中存放该类对应的实际会调用的函数地址（即若子类没有覆盖基类的虚函数，则对应位置存放基类虚函数地址；若子类覆盖了基类的虚函数，则对应位置存放子类的虚函数地址）。虚函数表以NULL结尾。且如果子类中添加了基类中没有的虚函数，则新加的虚函数被放在子类虚函数表最后。 
    虚函数表只存放虚函数的地址，非虚函数由编译器在编译期间静态设定。 
    如果一个子类是多继承，即含有多个基类，则有多个虚函数表，分别对应到不同的继承。

    可以通过对象的地址，得到虚函数表，单独调用类中的函数：

class A{
public:
	A(){
	}
	~A(){
	}
	virtual void f1(){
		cout << "f1 in class A" << endl;
	}
};
class B{
public:
	virtual void f2(){
		cout << "f2 in clas B" << endl;
	}
};
class D: public A, public B{
public:
	D(){
	}
	~D(){
	}
	void f1(){
		cout << "f1 in class D" << endl;
	}
	void f2(){
		cout << "f2 in class D" << endl;
	}
};
typedef void(*Func)();
int main(){
	D* d = new D();
    uint32_t* vtable_ptr = (uint32_t*)*(uint32_t*)d;//d为对象地址，*d即可获得VPTR值
	Func f = (Func)(*vtable_ptr);//*VPTR即为第一个虚函数的地址
	cout << "func's address is : " << *(uint32_t*)f << endl;
	f();    //调用,输出 "f1 in class D"
	return 0;
}

 


4. 单继承的对象在内存中的分配 
    单继承的对象，如果含有虚函数，则对象在内存中的布局为：开头为VPTR，然后为该对象的非静态成员变量，且为先基类的变量后子类的变量。且如果父类的非静态成员变量为private，子类中仍然会存在那些private的非静态数据。

class Test4{
public:
	virtual void f(){
		cout << "f in Test4" << endl;
	}
	int get_a(){
		return a;
	}
	int a;
	char c;
};
class Test4{
public:
	virtual void f4(){
		cout << "f4 in Test4" << endl;
	}
	int get_a(){
		return a;
	}
private:
	int a;
	char c;
};
int main(){
	int* pa = (int*)((char*)(&test4) + 4);  //+4，是为了跳过VPTR
	cout << "first member in test4 = " << *pa << endl;  //输出一个随机数
	*pa = 200;
	cout << "first member in test4 = " << test4.get_a() << endl; //输出200
	
	Test7 test7;
	cout << "sizeof test7 = " << sizeof(test7) << endl;
	//12字节，4字节的VPTR， 4字节的int a， 4字节（对齐后的）char c。
	pa = (int*)((char*)(&test7) + 4);
	cout << "first member in test7 = " << *pa << endl;
	*pa = 1000;
	cout << "first member in test7 = " << test7.get_a() << endl; //输出1000
	return 0;
}

 


结构图大致如下： 

5. 多继承的对象在内存中的分配 
    如果一个子类有多个基类，为多继承。其对象在内存中的布局为：按照多个继承，分为多个块；每块的开头为一种继承的虚函数表，接着为该种继承的基类的非静态成员变量（包括public，protected，private）；所有块结束之后，为该子类特有的非静态成员变量；如果该子类又新加了虚函数，则虚函数放在第一个虚函数表的最后。

class A{
public:
    virtual void f1(){
        cout << "f1 in class A" << endl;
    }
private:
    int a;
};
class B{
public:
    virtual void f2(){
        cout << "f2 in class B" << endl;
    }
    virtual void f4(){
        cout << "f4 in class B" << endl;
    }
    int b;
}
class D:public A, B{
public:
    void f1(){
        cout << "f1 in class D" << endl;
    }
    void f2(){
        cout << "f2 in class D" << endl;
    }
    virtual void f3(){
        cout << "f3 in class D" << endl;
    }
private:
    double c;
}

 

    以上类层次结构所对应的对象在内存中的布局为： 
            

6. 虚基类和虚继承

    如果有多个类继承自同一个基类，最后又被同一个子类继承这些类（例如 B, C继承自A， D继承自B,C），这种情况下，如果不使用虚继承，若类型A存在非静态成员变量a，则会有D类型的对象保留从B继承来的a和从C继承来的a，出现空间冗余。 
    而若使用虚继承，可以使得D从B继承来的a和从C继承来的a是同一个，节省空间。 
没有虚继承的代码和内存布局

class A{
public:
	virtual void f1(){
		cout << "f1 in class A" << endl;
	}
	virtual void f2(){
		cout << "f2 in class A" << endl;
	}
private:
	int a;
};
class B:public A{
public:
	void f1(){
		cout << "f1 in class B" << endl;
	}
	virtual void f4(){
	    cout << "f4 in class B" << endl;
	}
};
class C:public A{
public:
	void f2(){
		cout << "f2 i class C" << endl;
	}
	virtual void f3(){
		cout << "f3 in class C" << endl;
	}
};
class D :public B, C{
public:
	void f3(){
		cout << "f3 in class D" << endl;
	}
	int d;
};

typedef void(*Func)();
int main(){
	

	A obj_a;
	cout << "sizeof obj_a = " << sizeof(obj_a) << endl;

	B obj_b;
	cout << "sizeof obj_b = " << sizeof(obj_b) << endl;

	C obj_c;
	cout << "sizeof obj_c = " << sizeof(obj_c) << endl;

	D obj_d;
	cout << "sizeof obj_d = " << sizeof(obj_d) << endl;

	
	uint32_t* vptr_b = reinterpret_cast<uint32_t*>(*(uint32_t*)(&obj_d)); //指向vftable_b

	Func b_f1 = (Func)(reinterpret_cast<void*>(*vptr_b));
	b_f1();
	Func a_f2 = (Func)(reinterpret_cast<void*>(*(vptr_b + 1)));
	a_f2();
    Func b_f4 = (Func)(reinterpret_cast<void*>(*(vptr_b + 2)));
    b_f4();
    
	uint32_t* vptr_c = reinterpret_cast<uint32_t*>(*(uint32_t*)((char*)&obj_d + 8));
	Func a_f1 = (Func)(reinterpret_cast<void*>(*vptr_c));
	a_f1();
	Func c_f2 = (Func)(reinterpret_cast<void*>(*(vptr_c + 1)));
	c_f2();
	Func d_f3 = (Func)(reinterpret_cast<void*>(*(vptr_c + 2)));
	d_f3();
	return 0;
}

 

运行结果 
                     

内存布局 
               

使用虚继承的代码和内存布局 
    使用虚继承之后，公共的基类在子类中只有一份，在多重继承的基础上多了vbtable来存储到公共基类的偏移。

class A{
public:
	virtual void f1(){
		cout << "f1 in class A" << endl;
	}
	virtual void f2(){
		cout << "f2 in class A" << endl;
	}
	int get_a(){
		return a;
	}
private:
	int a;
};
class B:virtual public A{
public:
	void f1(){
		cout << "f1 in class B" << endl;
	}
	virtual void f4(){
		cout << "f4 in class B" << endl;
	}
};
class C:virtual public A{
public:
	void f2(){
		cout << "f2 in class C" << endl;
	}
	virtual void f3(){
		cout << "f3 in class C" << endl;
	}
};
class D :public B, public C{
public:
	void f3(){
		cout << "f3 in class D" << endl;
	}
	int get_d(){
		return d;
	}
private:
	int d;
};

typedef void(*Func)();
int main(){
	

	A obj_a;
	cout << "sizeof obj_a = " << sizeof(obj_a) << endl;

	B obj_b;
	cout << "sizeof obj_b = " << sizeof(obj_b) << endl;

	C obj_c;
	cout << "sizeof obj_c = " << sizeof(obj_c) << endl;

	D obj_d;
	cout << "sizeof obj_d = " << sizeof(obj_d) << endl;

	cout << "d in obj_d = " << obj_d.get_d() << endl;
	int* d_ptr = (int*)((char*)&obj_d + 16);
	*d_ptr = 200;
	cout << "d in obj_d = " << obj_d.get_d() << endl;

	cout << "a in obj_d = " << obj_d.get_a() << endl;
	int* a_ptr = (int*)((char*)&obj_d + 24);
	*a_ptr = 1000;
	cout << "a in obj_d = " << obj_d.get_a() << endl;


	uint32_t* vptr_b = reinterpret_cast<uint32_t*>(*(uint32_t*)(&obj_d)); //指向vftable_b

	Func b_f4 = (Func)(reinterpret_cast<void*>(*vptr_b));
	b_f4();

	uint32_t* vptr_c = reinterpret_cast<uint32_t*>(*(uint32_t*)((char*)&obj_d + 8));
	Func c_f3 = (Func)(reinterpret_cast<void*>(*(vptr_c)));
	c_f3();

	uint32_t* vptr_a = reinterpret_cast<uint32_t*>(*(uint32_t*)((char*)&obj_d + 20));
	Func a_f1 = (Func)(reinterpret_cast<void*>(*(vptr_a)));
	a_f1();

	Func a_f2 = (Func)(reinterpret_cast<void*>(*(vptr_a + 1)));
	a_f2();

	uint32_t* ptr = (uint32_t*)((char*)&obj_d + 4);
	cout << "ptr = " << *ptr << endl;

	ptr = (uint32_t*)((char*)&obj_d + 12);
	cout << "ptr = " << *ptr << endl;

	cout << "vptr.a = " << reinterpret_cast<uint32_t>(vptr_a) << endl;

	return 0;
	
}

 

运行结果 
                    

内存布局 
不同编译器可能不同，在vs2013上测试 
                    

    其中，继承的公共基类A只保留一份数据，且D中对应到基类B和C的虚函数表（vftable@B和vftable@C）中只保留在B或C中新引入的虚函数，而B和C从A中继承的公共虚函数放在vftable@A中。 
    vftable@B之后为vbtable@B，指向vftable@A，vftable@C之后为vbtable@C，指向vftable@A.

参考

http://blog.csdn.net/starryheavens/article/details/4549616
http://blog.sina.com.cn/s/blog_60e96a410100lirk.html

weixin_34228662
关注
C/C++面试题2「虚函数、多态、内存管理与软件调试篇」
dvlinker的技术专栏
10-01 5402
C/C++面试题分享「虚函数、多态、内存管理与软件调试篇」
C++之虚函数和虚函数表
编程与实战的博客
04-18 2175
哈喽大家好。最近开始学习计算机基础相关的面试内容，比如C++、算法与数据结构、计算机网络、操作系统、设计模式、数据库等。因此把学习时记的笔记分享给大家，希望对大家有所帮助。今天分享的是C++中虚函数和虚函数表相关知识，下面是正文。虚函数概念虚函数是在编译时，并不能确定的类函数，而是在运行时确定的。核心点：通过基类对象访问派生类实现的函数。例子虚函数的例子，通常有三步。第一...
C++虚函数及虚函数表解析
weixin_30527423的博客
08-06 221
1.虚函数的定义 　　虚函数必须是类的非静态成员函数(且非构造函数)，其访问权限是public（可以定义为private or proteceted, 但是对于多态来说，没有意义。），在基类的类定义中定义虚函数的一般形式：　　　　　　virtual 函数返回值类型 虚函数名（形参表）　　　　　　{ 函数体 } 虚函数的作用是实现动态联编，也就是在程序的运行阶段动态地选择合适的成员函数，在...
C++ 虚函数表原理和类的内存分布
恋恋风辰的技术博客
08-02 1731
C++ 虚函数表原理和类的内存分布
虚函数表，虚表指针与内存分配（一）
qq_43558142的博客
03-05 577
在此之前先了解下何为多态 多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。 简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。 虚继承的作用是减少了对基类的重复，代价是增加了虚表指针的负担（更多的虚表指针）。 （当基类有虚函数时）： .1. 每个类都有虚指针和虚...
【C++】虚函数及其内存布局
Jacky_Feng的博客
10-18 1981
一、函数调用捆绑 把函数体与函数调用相联系称为捆绑。 当捆绑在程序运行之前（由编译器和连接器）完成时，称为早捆绑。C编译只有一种函数调用方式，就是早捆绑。 早捆绑引起的问题：因为编译器在只有对象的地址时它并不知道要调用的正确函数。 根据对象的类型，捆绑发生在运行时，这种捆绑方式称为晚捆绑，又称动态捆绑。 二、虚函数 对于特定的函数，为了引起晚捆绑，C++要求在基类中声明这个函数时使用virtual关键字，这样的函数称为虚函数。晚捆绑只对virtual函数起作用，而且只在使用含有virtual函.
c++类和对象
weixin_42693876的博客
09-11 277
类和对象 类和结构体一样的，是个自定义的数据类型，同时类和结构体是很像的，包括内存大小等性质都很像。 （1）类的定义 class Box { protected: // 访问修饰符 double length = 1.0; double breedth = 1.0; double height = 1.0; public: double get(); void set(double len, double bre, double hei); }; // 类的定义结束后有分号 d
浅谈C++对象的内存分布和虚函数表
08-31
C++是一种静态类型的语言，它的内存分配和管理对于理解程序的执行至关重要，特别是涉及到对象的内存分布和虚函数表时。本文将详细探讨这两个...同时，合理地使用虚函数和继承策略可以极大地提升代码的复用性和灵活性。
简述C++中虚拟函数的内存分配机制
08-18
当我们调用 pMem->funOver() 时，编译器会根据 pMem 的对象内存地址找到适当的虚函数地址。 在上面的示例程序中，我们首先定义了一个基类 CMem，包括一个虚拟函数 funOver()。然后，我们定义了一个派生类 CMemSub，...
C++ 内存对象布局
11-08
当子类添加了虚函数时，对象内存中除了父类成员和自身成员外，还会加入虚函数指针。虚函数指针的位置根据编译器的不同而有所不同，但通常是放在最前面或成员变量之后。 ##### 3. **单一继承，有成员变量且有虚函数...
虚函数 类空间占用大小
maxiaozhuang的专栏
09-23 6112
总结一下VPTR 和 VTABLE 和类对象的关系:        每一个具有虚函数的类都有一个虚函数表VTABLE，里面按在类中声明的虚函数的顺序存放着虚函数的地址，这个虚函数表VTABLE是这个类的所有对象所共有的，也就是说无论用户声明了多少个类对象，但是这个VTABLE虚函数表只有一个。        在每个具有虚函数的类的对象里面都有一个VPTR虚函数指针，这个指针指向VTABLE的首
C++ 虚函数表 vfptr
好记性不如烂笔头
09-25 2万+
前言大家都应该知道C++的精髓是虚函数吧? 虚函数带来的好处就是: 可以定义一个基类的指针, 其指向一个继承类, 当通过基类的指针去调用函数时, 可以在运行时决定该调用基类的函数还是继承类的函数. 虚函数是实现多态(动态绑定)/接口函数的基础. 可以说: 没有虚函数, C++将变得一无是处!既然是C++的精髓, 那么我们有必要了解一下她的实现方式吗? 有必要! 既然C++是从C语言的基础上发展而来的
c++虚函数实现机制及内存模型
mightySheldor的专栏
11-19 6197
前言 大家都应该知道C++的精髓是虚函数吧? 虚函数带来的好处就是: 可以定义一个基类的指针, 其指向一个继承类, 当通过基类的指针去调用函数时, 可以在运行时决定该调用基类的函数还是继承类的函数. 虚函数是实现多态(动态绑定)/接口函数的基础. 可以说: 没有虚函数, C++将变得一无是处! 既然是C++的精髓, 那么我们有必要了解一下她的实现方式吗? 有必要! 既然C++是从C语言
C++ 内存划分与虚函数表在内存中的位置
Zinthos 的笔记本
09-05 2796
一直都不清楚C++的内存具体是怎样划分的，只知道大致有堆区、栈区、全局静态区、常量区等划分。如果没记错的话，好像还有一个代码区。 那么，我们知道C++里的虚函数是借助虚函数表实现的，含有虚函数的类的对象中有一个指向虚函数的指针（通常是对象前4个字节（32位））。现在的问题是虚函数表是保存在内存中的哪个部分中呢？
C++继承与多态三：虚函数、静态绑定与动态绑定问题、虚析构函数
Rain的博客
03-14 475
文章目录一、虚函数与静态绑定、动态绑定问题二、虚析构函数三、深入动态绑定问题 一、虚函数与静态绑定、动态绑定问题 虚函数： 在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数。 注意： 1.一个类里面定义了虚函数，那么编译阶段，编译器需给这个类类型产生一个唯一的vftable虚函数表。虚函数表中主要存储的内容就是RTTI指针和虚函数的地址。当程序运行时，每一张虚函数表都会...
C++多态
lx8211667846947的博客
10-03 293
一、C++多态 多态是指一组具有继承关系的类，拥有相同的接口（函数名、形参和返回值），并允许有各自不同的实现，且一个对象实例只有在调用这共同接口的时候，才能确定调用的是何种实现。 即，“一个接口，多种实现”二、静态多态 编译器在编译期间完成的 静态多态 : 通过”彼此单独定义但支持共同操作的具体类“来表达共同性。 函数多态：即函数重载 概念：基于不同的参数列表，同一函数名可指向不同的函数
2019届 字节跳动C++校招面经（一二三hr面，已拿offer）
热门推荐
我的大学
03-15 2万+
双非学校，大四无实习经验，考研难民。。 考完研之后参加的第一次面试。 现在发出面经来回馈一下前面看过的那么多面经。 一面和二面都是同一天面的，hr在三面后的两天后。 （题目顺序有些不分先后，但大致有序） 第一面（50 min） 1、进程和线程的区别和其使用等 常规题。 2、tcp和udp的区别 常规题。 3、http协议和https协议的不同和其大概原理 还好前几天看了一篇HTTPS的科普，我就讲...
C++中虚函数继承类的内存占用大小计算
时间溜走了的博客
06-16 1011
计算一个类对象的大小时的规律： 1、空类、单一继承的空类、多重继承的空类所占空间大小为：1（字节，下同）； 2、一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间的； 3、因此一个对象的大小≥所有非静态成员大小的总和； 4、当类中声明了虚函数（不管是1个还是多个），那么在实例化对象时，编译器会自动在对象里安插一个指针vPtr指向虚函数表VTable； 5、虚承继的情况：由于涉及到虚函数表和虚基表，会同时增加一个（多重虚继承下对应多个）vfPtr指针指向虚函数
C++中多态,虚函数,动态联编与静态联编, 函数重载与重写
ljmiiianng的博客
10-07 1461
多态( 静态多态 和 动态多态) (个人理解)多态与联编的区别: 多态指的是一个结果, 一个最终的状态, 指一个东西实现了通过多种形态表现出来了; 联编指的是用于实现和达到多态的一种方式方法. 多态:通过多种形态表现出来. 种类:如函数重载: 通过令传入函数的参数列表中的 参数个数不同, 类型不同, 顺序不同 使得函数名有多种形态来表现 静态多态: 如函数重载和运算符重载, 复用函数名 动态多态:...
C++内存结构解析：对象与虚函数表
- **虚函数表（VTable）**：每个含有虚函数的类会产生一个VTable，存储虚函数的地址，不包含在对象内存中。 - **虚函数指针（VPoint）**：每个对象包含一个指向VTable的指针，用于动态绑定。 3. **函数调用与`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值