【C++面向对象】类的数据成员：绑定、布局和存取

最新推荐文章于 2024-04-10 09:11:49 发布

没有昵称阿

最新推荐文章于 2024-04-10 09:11:49 发布

阅读量3k

点赞数

CC 4.0 BY-SA版权

分类专栏： C/C++ 文章标签： c++ float 编译器 class binding struct

本文链接：https://blog.youkuaiyun.com/xiajun07061225/article/details/7583592

C/C++ 专栏收录该内容

36 篇文章

订阅专栏

本文详细探讨了C++中数据成员的绑定、布局及存取方式。解释了成员函数中的变量解析规则，以及如何确定成员在类对象中的排列顺序。同时，还介绍了静态和非静态数据成员的区别及其在内存中的存储位置。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、数据成员的绑定（The binding of a data member）

先看一段代码：

//某个头文件，从某处含入
extern float x;

class Point3d
{
public:
	Point3d(float,float,float);

	float X()
	{
		return x;
	}
	void X(float new_x)
	{
		x = new_x;
	}

private:
	float x,y,z;
};

现在的问题是：在类的两个成员函数X中，被返回和设定的x是哪一个呢？是extern声明的x还是类的成员变量x呢？

在现在的编译器中，一般都指的是类中的成员变量x。但是在C++最早的编译器中则不是这样做的。因此导致了两种程序设计风格：

（1）把所有的数据成员放在类的声明的起始处。

（2）所有的内联函数都放在类声明之外。

虽然他们的必要性已经自C++2.0之后消失了，但是这种程序设计风格在今天依然存在。这个古来的语言规则被称为“member rewriting rule”，意思是“一个内联函数实体，在整个类声明未被完全看见之前，是不会被评估求值的”。C++标准中的效果是：一个内联函数在类声明之后立即被定义的话，依然对他评估求值，但是是在整个类声明完成之后才开始。

但是对于成员函数的参数列表则不是这样的。参数列表中的参数还是i会在它们第一次遇到时被决议。例如：

typedef int length;

class Point3d
{
public:
	void mumble(length val)
	{
		_val = val;
	}
	length mumble()
	{
		return _val;
	}

private:
	typedef float length;
	length _val;
};

两个函数umber中的length会被决议为int，但是后续出现的length声明则会使先前的操作不合法。
因此，我们最好把嵌套类型声明放在类的起始处。

二、数据成员的布局（Data member layout）

先看下面一个类的定义：

class Point3d
{
public:
	//...

private:
	float x;
	static List<Point3d*> *freeList;
	float y;
	static const int chunksize = 250;
	float z;
};

数据成员的布局情况是：

（1）非静态成员在类对象中的排列顺序和声明顺序一致，任何在其中间声明的静态成员都不会被放进对象布局中。

（2）静态数据成员存放在程序的data segment中，和个别类对象无关。

注：data segement（来自维基百科）：

是程序的虚地址空间的一部分，包含全局变量和静态变量，其大小由程序在运行之前程序员所放置的变量决定。

Program memory包括三部分：

（1）Data Segment(Data + BSS + Head)l

（2）Stack

（3）Code Segment

C++标准规定，在同一个访问块即private、public、protected等区段中，成员的排列只需符合较晚出现的成员在类对象中有较高的地址即可。也就是说，并不一定要连续排列。

什么东西可能介于被声明的成员之间的？由于对齐可能需要填补一些字节。

编译器还会合成一些内部使用的数据成员，以支持整个对象模型。比如指向虚函数表的指针vptr。vptr的放置位置由编译器决定。传统是放在类的所声明的成员的最后。

C++标准允许编译器把多个访问块指针的数据成员自由排列，而不必在乎在类声明中的次序。

当前的众多编译器都是把一个以上的访问块连锁在一起，依照声明次序形成一个连续区块。而且访问块的多少不会带来额外负担。

例如在一个访问块中声明4个成员和在4个访问块中分别声明一个成员得到的对象大小相同。

判断一个类中两个成员谁先谁后可用如下代码实现：

template<class class_type,
			class data_type1,
			class data_type2>
				char* acess_order(data_type1 class_type::*mem1,
											data_type1 class_type::*mem2)
			{
				assert(mem1 != mem2);
				return mem1 < mem2
					? "mem1 first"
					: "mem2 first";
			}

三、数据成员的存取

静态数据成员

每一个静态数据成员只有一个实体，被各个类对象所共享。它被存放在程序的data segment中，并被视为一个全局变量，值在类声明范围之内。

注意：每一静态成员的存取许可（private、protected和public）以及与类的关联并不会导致任何空间或执行时间上的额外负担。

每次程序对静态成员的调用，都会被内部转化为该唯一的实体的直接操作。所以通过指针或对象来调用静态成员，效果完全相同。比如

Point3d origin,*pt = &origin;
origin.x = 0.0;
pt ->x = 0;

这也是C++中通过指针和通过对象存取数据成员结果完全相同的唯一情况。

这是因为，静态数据成员并不在类对象之中，存取静态成员不需要通过类对象。通过操作符“.”进行存取只是语法上的一种便宜行事而已。
如果静态数据成员是从一个复杂关系中继承而来的，那么程序中也依然只有一个实体，存取依然是直接的。

如果取一个静态数据成员的地址，会得到一个指向其数据类型的指针，而不是指向其类成员的指针，因为静态成员并不在类对象之中。

比如：

#include <iostream>
#include <typeinfo>
using namespace std;

class Point3d
{
public:
	float x;
	static const int chunksize = 250;
	float z;
};

int main()
{
	cout << typeid(&Point3d::chunksize).name() << endl;
	cout << typeid(&Point3d::x).name() << endl;
}

程序输出：

如果有两个类，都声明了同一个静态成员比如sta_mem，当它们都被放在程序的data segment时，会导致名称冲突，编译器会进行解决：暗中对每一个静态数据成员编码以获得唯一的程序识别代码。

class base1
{
public:
	base1(int x=8):a(x){};//const成员在构造函数初始化
	const int a;
	static int b;
	const static int c=9;//const static成员在类内初始化
};

class base2
{
public:
	base2(int x=8):a(x){};//const成员在构造函数初始化
	const int a;
	static int b;
	const static int c=9;//const static成员在类内初始化
};

int base1::b=9;//static成员在类外初始化，可以修改
int base2::b=10;//static成员在类外初始化，可以修改

int main()
{
	base1 obj1;
	base2 obj2;
	cout<<base1::b<<endl;
	cout<<base2::b<<endl;
}

程序会输出9和10.

非静态数据成员

存放在每一个类对象中，只有经由显式的（explicit）或者隐式的（implicit）类对象才能存取。

程序员在成员函数中处理非静态数据成员，隐式的类对象就会发生。比如：

void Point3d::translate(const Point3d &pt)
{
	x += pt.x;
	y += pt.y;
	z += pt.z;
}

事实上x、y、z的存取是经由this指针完成的。其函数参数应该是：

void Point3d::translate(Point3d * const this,const Point3d &pt)
{
	this ->x += pt.x;
	this ->y += pt.y;
	this ->z += pt.z;
}

每一个非静态数据成员的偏移量在编译时期即可获得，即便这个成员属于一个基类（派生自单一或者多重继承串链）子对象也是一样的。

因此，存取一个非静态数据成员的效率和存取一个C struct成员或者非继承类的成员是相同的。

下面看看虚拟继承。虚拟继承将为经由基类子对象存取类成员导入一层新的间接性。比如

Point3d *pt1;
Point3d pt2;
pt1 ->_x = 0;
pt2._x = 0.1;

从类指针存取和从类对象存取有什么重大差异？

当类Point3d是一个继承类，在其继承结构中有一个虚拟基类，并且被存取的成员是从该基类继承未来的时候，就会有大的差异。

因为在这个时候我们不知道pt1到底指向那种类类型，也就不知道这个成员的真正偏移量。所以存取操作要被延迟至执行期，经由一个额外的导引，才能解决。

但是用类对象来存取则不会导致这样的问题。