深入探索C++对象模型(Inside the C++ object model) -- 摘阅笔记（关于对象

Object Lessons 关于对象

在C语言中，“数据”和“处理数据的操作（函数）”是分开声明的，也就是说 ，语言本身并没有支持“数据和函数”之间的关联性。把这种程序方法称为程序性(procedural)，由一组“分布在各个以功能为导向的函数中”的算法所驱动，它们处理的是共同的外部数据。

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

//打印一个Point3d,就需要定义一个这样的函数
void Point3d_print(const Point3d *pd)
{
  printf("(%g, %g, %g)", pd->x, pd->y, pd->z);
}
//为了效率高点，可以定义成宏
#define Point3d_print( pd ) 
    printf("(%g, %g, %g)", pd->x, pd->y, pd->z);

//更直接的是直接在一个程序中完成操作
void my_foo()
{
  Point3d *pd = get_a_point();
  ....
  /* 直接打印出 point .... */
  printf("(%g, %g, %g)", pd->x, pd->y, pd->z)；
}

//对于某个点的坐标可以直接存取
Point3d pt;
pt.x = 0.0;
// 或者直接定一个处理宏
#define X(p, xval) (p.x) = (xval)
...
X(pt, 0.0);

在C++中， Point3d采用“抽象数据类型(abstract data type, ADT)”来实现:

class Point3d 
{
  friend ostream& operator<<(ostream &os, const Point3d &pt);
public:
    Point3d(float x = 0.0, float y = 0.0, float z = 0.0)
    :_x(x), _y(y), _z(z){}
  
  float x() const { return _x; }
  float y() const { return _y; }
  float z() const { return _z; }
  
  void x(float xval ) { _x = xval; }
  void y(float yval ) { _y = yval; }
  void z(float zval ) { _z = zval; }
  
private:
  float _x;
  float _y;
  float _z;
};
inline ostream& operator<<(ostream &os, const Point3d &pt)
{
    os << "(" << pt.x() << "," << pt.y() << "," << pt.z() << ")";
};

或者一个双层或者三层clasa层结构完成

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

class Point2d : public 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: public 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 T>
class Point3d
{
public:
  Point3d(T x = 0.0, T y = 0.0, T z = 0.0)
    : _x(x), _y(y),_z(z) {}
  
 T x() const { return _x; }
 T y() const { return _y; }
 T z() const { return _z; }
 
 void x(T xval ) { _x = xval; }
 void y(T yval ) { _y = yval; }
 void z(T zval ) { _z = zval; }
 
private:
  T _x, _y, _z;
};

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

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

从软件工程的眼光来看，为什么“一个ADT或class hierarchy的数据封装”比“在C程序中程序性地使用全局数据”好。

加上封装后的布局成本(layout costs for adding Encapsulation)

增加封装后，布局成本增加了多少？答案是 class Point3d并没有增加多少成本。三个data membeers 直接内含在一个class objects之中，就像C struct 的情况一样。而member function虽然含在class的声明之内，却不出现在object之中。 每一个non-inline member function只会诞生一个函数实例。至于每一个“拥有零个或一个定义的”的inline function 则会在其每一个使用者（模块）身上产生一个函数实例。

C++在布局以及存取时间上主要的额外负担是由virtual引起的， 包括；

• Virtual function 机制，用以支持一个有效的“执行期绑定”(runtime binding)

• Virtual base class 用以实现“多次出现在继承体系中的base class, 有一个单一而被共享的实例“

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

一般，没有什么天生的理由说C++程序一定比其C程序庞大或迟缓。