《深度探索C++对象模型》——C++与C程序风格对比

在C语言中，“数据”和“处理数据的操作（函数）”是分开来声明的。由一组“分布在各个以功能为导向的函数中”的算法所驱动，处理共同的外部数据。

先看一个例子：

如果我们声明一个struct Point3d，

typedef struct point3d
{
float x;
float y;
float z;
}Point3d;

欲打印一个Point3d，可能就得定义一个像这样的函数：

void
Point3d_print( const Point3d *pd)
{
printf("(%g, %g, %g)\n", pd->x, pd->y, pd->z);
}

或者，定义这样的宏：

#define Point3d_print( pd ) \
printf("(%g, %g, %g)\n", pd.x, pd.y, pd.z);

或者，直接在程序调用处完成其操作：

void
my_foo()
{
Point3d *pd = get_a_point();
...
/*直接打印出  point ...*/
printf("(%g, %g, %g)\n", pd.x, pd.y, pd.z);
}

同样的道理，某个点的特定坐标值可以直接存取：

Poind3d  pt;
pt.x = 0.0;

或者，

#define X( p, xval ) (p.x) = (xval);
…
X( pt, 0.0);

在C++中，Point3d有可能用独立的“抽象数据类型（ADT）”来实现：

class Point3d
{
public:
Point3d( float x = 0.0, float y = 0.0, float z = 0.0 ):
_x(x), _y(y), _z(z){}
~Point3d(){}
float x(){ return _x;}
float y(){ return _y;}
float z(){ return _z;}
//...etc..
private:
float _x;
float _y;
float _z;
};

inline ostream&
operator<<(ostream &os, const Point3d &pt)
{
os << "(" << pt.x << "," << pt.y << "," << pt.z << ")";
};

或者，

class Point {
public:
Point( float x = 0.0 ):_x(x){}
float x(){return _x;}
void x( float xval ){ _x = xval;}
//...
protected:
float _x;
};

class Point2d : Point {
public:
Point2d( float x = 0.0, float y = 0.0 ):Point(x), _y(y){}
float y(){ return _y; }
void y( float yval ){ _y = yval; }
//...
protected:
float _y;
};

class Point3d : Point2d {
public:
Point3d( float x = 0.0, float y = 0.0, float z = 0.0 ):Point2d(x, y), _z(z){}
float z(){return _z;}
void z( float zval ){ _z = zval;}
//...
protected:
float _z;
};

或者，坐标类型参数化：

template < class type >
class Point3d
{
public:
Point3d( type x = 0.0, type y = 0.0, type z = 0.0 ):
_x(x), _y(y), _z(z){}
~Point3d(){}
type x(){ return _x;}
type y(){ return _y;}
type z(){ return _z;}
void x( type xval ){ _x = xval;}
//...etc..
private:
type _x;
type _y;
type _z;
};

或者，坐标类型和坐标数目均参数化：

template< class type, int dim>
class Point
{
~Point(){};
Point( type coords[dim] ){
for( int index = 0; index < dim; index++ )
__coords[index] = coords[index];
}
type& operator[]( int index ){
assert(index < dim && index >= 0);
return __coords[index];
}
//...etc...
private:
type __coords[dim];
};

inline
template< class type, int dim>
ostream&
operator<<( ostream &os, const Point< type, dim> &pt )
{
os << "(";
for ( int ix = 0; ix < dim - 1; ix++)
{
os << pt[ix] << ", ";
}
os << pt[dim - 1];
os << ")";
};

根据上面的例子，很明显的看出，C 程序和 C++ 程序风格上有截然不同，在程序的思考上也有明显的差异。大家看到 Point3d 转到 C++ 之后，是不是反而更加复杂？布局成本是不是增加更多了？答案是 class Point3d 并没有增加成本。三个 data member 直接内含在每一个 class object 之中，就像 C struct 的情况一样。而 member function 虽然含在 class 的声明之内，却不出现在 object 之中。每一个 non-line member function 只会诞生一个函数实体，而不是 inline function 在每一个模块使用者身上产生一个函数实体。事实上，C++ 在布局以及存取时间上主要的额外负担是由 virtual 引起的，包括：

virtual function 机制 用以支持一个有效率的“执行期绑定”（running binding）

virtual base class 用以实现“多次出现在继承体系中的base class ，有一个单一而被共享的实体”。

此外，还有一些多重继承下的额外负担，发生在“一个derived class 和其二或者后继之 base class的转换”之间。

至此，你也许会问，你咋知道 C++ 的布局成本没有增加成本？C++ 布局又是咋样的？这里面说的 virtual又是怎么给 C++ 在布局以及存取时间上引起额外的负担？敬请关注下一篇博客《C++对象模型》。