C++对象模型——程序转化语意学(第二章)

2.3    程序转化语意学 (Program Transformation Semantics)

#include "X.h"
X foo() {
    X xx;
    return xx;
}

明确的初始化操作 (Explicit Initialization)

X x0;
//下面有三个定义，每一个都明显地以x0来初始化其 class object：
void foo_bar() {
    X x1(x0);
    X x2 = x0;
    X x3 = X(x0);
}

//    可能的程序转换
//    C++伪码
void foo_bar() {
    X x1;    //定义被重写，初始化操作被剥除
    X x2;    //定义被重写，初始化操作被剥除
    X x3;    //定义被重写，初始化操作被剥除
    //    编译器插入X copy constructor的调用操作
    x1.X::X(x0);
    x2.X::X(x0);
    x3.X::X(x0);
}

x1.X::X(x0);

X::X(const X &xx);

参数的初始化 (Argument Initialization)

X xx = arg;

void foo(X x0);

X xx;
foo(xx);

// C++伪码
// 编译器产生出来的暂时对象
X __temp0;
// 编译器对copy constructor的调用
__temp0.X::X(xx);    
// 重新改写函数调用操作，以便使用上述的暂时对象
foo(__temp0);

void foo(X &x0);

返回值的初始化 (Return Value Initialization)

X bar() {
    X xx;
    // 处理xx...
    return xx;
}

// 函数转换以反映出copy constructor的应用
// C++伪代码
void bar(X &__result)    // 加上一个额外参数
{
    X xx;
    // 编译器所产生的default constructor调用操作
    xx.X::X();
    // ...处理xx
    // 编译器所产生的copy constructor调用操作
    __result.X::XX(xx);
    return;
}

X xx = bar();

// 注意，不必施行default constructor
X xx;
bar(xx);

bar().memfunc();

// 编译器所产生的暂时现象
X __temp0;
(bar(__temp0), __temp0).memfunc();

X (*pf)();
pf = bar;

void (*pf)(X &);
pf = bar;

在使用者层面做优化 (Optimization at the User Level)

X bar(const T &y, const T &z) {
    X xx;
    // ...以y和z来处理xx
    return xx;
}

X bar(const T &y, const T &z) {
    return X(y, z);
}

// C++伪代码
void bar(X &__result)
{
    __result.X::X(y, z);
    return;
}

在编译器层面做优化 (Optimization at the Compiler Level)

bar()定义：
X bar() {
    X xx;
    // ...处理xx
    return xx;
}

void bar(X &__result) {
    // default constructor 被调用
    // C++伪代码
    __result.X::X();
    // ...直接处理__result
    return;
}

class test {
    friend test foo(double);
public:
    test() {
        memset(array, 0, 100 *sizeof(double));
    }
private:
    double array[100];
};

test foo(double val) {
    test local;
    
    local.array[0] = val;
    local.array[99] = val;

    return local;
}

main()
{
    for (int cnt = 0; cnt < 10000000; cnt++) {
        test t = foo(double(cnt));
    }
    return 0;
}
// 整个程序的意义是重复循环1000万次，每次产生一个test object
// 每个test object配置一个拥有100个double的数组，所有的元素都设初值为0
// 只有#0和#9元素以循环计数器的值作为初值

inline test::test(const test &t) {
    memcpy(this, &t, sizeof(test));
}
// 不要忘记在 class test声明中加上一个member function如下
// public:
// inline test(const test &t);

void foo() {
    // 这里希望有一个copy constructor
    X xx = bar();
    // ...
    // 这里调用destructor
}

X xx0(1024);
X xx1 = X(1024);
X xx2 = (X)1024;

// C++伪代码
xx0.X::X(1024);

// C++伪代码
X __temp0;
__temp0.X::X(1024);
xx1.X::X(__temp0);
__temp0.X::~X();

Copy Constructor：要还是不要？

class Point3d {
public:
    Point3d(float x, float y, float z);
private:
    float _x, _y, _z;
};

Point3d operator+(const Point3d &, const Point3d &);
Point3d operator-(const Point3d &, const Point3d &);
Point3d operator*(const Point3d &, int);

{
    Point3d result;
    // 计算result
    return result;
}

Point3d::Point3d(const Point3d &rhs) {
    _x = rhs._x;
    _y = rhs._y;
    _z = rhs._z;
}
    这没问题，但使用C++ library的memcpy()会更有效率：
Point3d::Point3d(const Point3d &rhs) {
    memcpy(this, &rhs, sizeof(Point3d));
}

class Shape {
public:
    // 这会改变内部的vptr
    Shape() {
        memset(this, 0, sizeof(Shape));
    }
    virtual ~Shape();
};

// 扩张后的constructor
// C++伪代码
Shape::Shape() {
    // vptr必须在使用者的代码执行之前先设定妥当
    __vptr__Shape = __vtbl__Shape;
    // memset会将vptr清为0
    memset(this, 0, sizeof(Shape));
};

总结

原文：http://blog.csdn.net/yiranant/article/details/47171553