程序的转化 & 明确的初始化操作 & 参数的初始化 & 返回值的初始化

一丶程序的转化
考察以下代码:

1 X Foo()

2 {

3     X xx;

4     //...

5     return xx;

6 }

看到这个, 你可能会有两个想法:
1. 每次 Foo() 被调用, 就会传回 xx 的值.
2. 如果 class X 定义了一个 copy constructor, 那么当 Foo() 被调用时, 保证该 copy constructor 也会被调用.

这两个假设的真实性实际都要以 class X 如何定义而定, 在一个高品质的 C++ 编译器中, 以上两个假设都是错误的.

二丶明确的初始化操作
考察以下代码:

X x0;

void FooBar()

{ 

    X x1(x0); 

    X x2 = x0; 

    X x3 = X(x0); 

}

编译器对于以下代码有两个转化:
1. 重写每个定义, 剥除初始化操作.
2. class 的 copy constructor 的调用操作会安插进去.
可能的代码如下:

void FooBar()

{

    //剥离初始化操作

    X x1;

        X x2; 

        X x3;



    //安插 copy constructor 的代码

    x1.X::X(x0);

    x2.X::X(x0);

    x3.X::X(x0);

}

其中如 x1.X::X(x0) 就是对 X::X(const X&) 的调用.

三丶参数的初始化
考察以下代码:

void Foo(X x){/* ... */}

X xx;

Foo(xx);

将会要求局部实体(local instance) x0 以深拷贝的方式将 xx 作为初值. 这个策略是使用一个暂时性的 object, 调用 copy constructor 初始化后把它传入函数. 因此实际上可能的代码为:

//暂时对象

X __temp0;



//调用 copy constructor

__temp0.X::X(xx);

void Foo(__temp0);

如此存在一个问题, __temp0 是以 bitwise 的方式拷贝到 Foo() 的作用域中的, 但若是这样, Foo(X x) 便要变成 Foo(X &x), 因此, 至此编译器只是做了一半工作, 接下来的动作可能在接下来的章节有所描述.

四丶返回值初始化
考察以下代码:

X Bar()

{

    X xx;

    //...

    return xx;

}

怎样把 Bar() 的返回值从 xx 这个局部变量中拷出来?
考察以下代码:

//可能的代码

void Bar(X &__result)            　　　　　//额外的参数

{

    X xx;                       　　　　　 //剥离

    xx.X::X()              　　　　　　　　 //default constructor

    //...

    __result.X::X(xx);        　　　　　　 //编译器产生的 copy constructor 操作

    return;

}



所以对于 Bar():

//你看到的

X xx = Bar();



//可能实际的代码

X xx;

Bar(xx);



//你看到的

Bar().MemberFunc()            　　　　　　 //MemberFunc() 为 class X 的 member function



//可能实际上的代码

X __temp0;                　　　　　　　　  //编译器会产生一个临时 object

(Bar(__temp0), __temp0).MemberFunc();



//你看到的

X (*pf)();

pf = Bar;                　　　　　　　　　　//pf 为 函数指针



//可能实际的代码

X (*pf)(X&)               　　　　　　　　　//实际此函数指针与该函数的真面目相同

pf = Bar;