程序转化语意学 Program Transformation Semantics

显示的初始化操作

已有定义

X x0;

下边三个定义，显式的使用x0初始化

void foo(){ X x1(x0); X x2 = x0; X x3 = X(x0); }

将被编译器转化为调用class 的 copy constructor

void foo(){
    X x1;
    X x2;
    X x3;
    x1.X::X(X0);//调用X::X(const X& xx);
    x2.X::X(X0);
    x3.X::X(X0);
}

参数的初始化（Argument Initialization）

定义函数

void foo(X x0);

下边这样的调用方式：

X xx;
foo(xx);

将会导入临时性的object ，并调用copy constructor 使用 xx将其初始化，然后将此临时性object交给函数。
前段程序将转化如下：

X xx;
X _temp0;
_temp0.X::X(xx);
foo(_temp0);

foo声明会转化成：

void foo(X& x0);

在foo函数完成后会调用临时性object的destructor。
例子：

#include <iostream>
class X{
public:
    X(){
        printf("X default Constructor\n");
    }
    X(const X& xx){
        printf("X copy constructor\n");
    }
    ~X(){
        printf("X del\n");
    }
};
void foo(X x0){
    printf("foo is running\n");
}
int main(int argc, const char * argv[]) {
    X xx;
    printf("foo will running\n");
    foo(xx);
    printf("foo has die\n");
    return 0;
}

输出：
X default Constructor   //X xx 执行的default Constructor
foo will running
X copy constructor      //临时性object使用copy constructor初始化
foo is running      
X del                   //删除临时性object
foo has die
X del                   //程序结束，删除xx

返回值的初始化

如下函数定义

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

bar产生的返回值如何从局部变量xx中copy过来？
首先加上一个额外的参数，类型是class object 的 一个 reference，这个参数用来放置copy constructor而得的返回值；
然后再return之前安插一个copy constructor调用操作，使函数不传回任何值。
bar()将会被转化为:

void bar(X& _result){   //加上了额外的参数，改变了返回值类型
    X xx;
    xx.X::X();//初始化xx
    //处理xx
    _result.X::X(xx); //使用copy constructor
    return;
}

上面这种转化方式将调用copy constructor。我们可以直接以_result代替xx来处理。这样就不需要调用copy constructor了。这种编译器的优化操作称为Named Return Valie(NVR),如今被视为c++标准，bar()被优化为：

void bar(X& _result){   //加上了额外的参数，改变了返回值类型
    _result.X::X();
    //直接处理_result
    return;
}

编译器还需转化函数的调用操作

X xx = bar();
//将会转化为：
X xx;
bar(xx);

bar.memfunc();
//被转化为
X _temp0;//编译器产生的临时对象
bar(_temp0);
_temp0.memfunc();


//函数指针
X (*pf) ();
pf = bar;
//将会被转化为
void (*pf)(X&);
pf = bar;

测试：

class X{
public:
    X(){
        printf("X default Constructor\n");
    }
    X(const X& xx){
        printf("X copy constructor\n");
    }
    ~X(){
        printf("X del\n");
    }
};
X bar(){
    X xx;
    return xx;
}
int main(int argc, const char * argv[]) {
    bar();
    return 0;
}

输出：
X default Constructor
X del