Effective C++笔记之十四：以pass-by-reference-to-const替换pass-by-value

       缺省情况下C++ 以by value方式(一个继承自C 的方式)传递对象至(或来自)函数。函数参数都是以实际实参的复件(副本)为初值。这些复件(副本)系由对象的copy构造函数产出，这可能使得pass-by-value成为昂贵的(费时的)操作。考虑以下class 继承体系:

class Person {  
public:  
    Person ();  
    virtual ~Person();  
    ......  
private:  
    std::string name;  
    std::string address;  
};  
class Student: public Person {  
public:  
    Student();  
    ~Student();  
    ......  
private:  
    std::string schoolName;  
    std::string schoolAddress;  
};  

       现在考虑以下代码，其中调用函数validateStudent ，后者需要一个Student 实参(by value) 并返回它是否有效:

bool validateStudent(Student s);        // 函数以by value方式接受学生  
Student plato;                          // 柏拉图，苏格拉底的学生  
bool platoIsOK = validateStudent(plato);// 调用函数  

        当上述函数被调用时，发生什么事?
       无疑地Student 的copy构造函数会被调用，以plato 为蓝本将s 初始化。同样明显地，当validateStudent遗回s 会被销毁。因此，对此函数而言，参数的传递成本是"一次Student copy构造函数调用，加上一次Student析构函数调用"。
       但那还不是整个故事喔。Student对象内有两个string对象，所以每次构造一个Student对象也就构造了两个string对象。此外Student 对象继承自Person 对象，所以每次构造Student对象也必须构造出一个Person对象。一个Person对象又有两个string对象在其中，因此每一次Person构造动作又需承担两个string构造动作。最终结果是，以by value方式传递一个Student对象会导致调用一次Student copy构造函数、一次Person copy 构造函数、四次string copy 构造函数。当函数内的那个Student复件被销毁，每一个构造函数调用动作都需要一个对应的析构函数调用动作。因此，以by value 方式传递一个Student对象，总体戚本是"六次构造函数和六次析构函数" !

       这是正确且值得拥有的行为，毕竟你希望你的所有对象都能够被确实地构造和析构。但尽管如此，如果有什么方法可以回避所有那些构造和析构动作就太好了。有的，就是pass by reference-to-const:

bool validateStudent(const Student& s);  

        这种传递方式的效率高得多:没有任何构造函数或析构函数被调用，因为没有任何新对象被创建。修订后的这个参数声明中的const 是重要的。原先的validateStudent以by value 方式接受一个Student参数，因此调用者知道他们受到保护，函数内绝不会对传入的Student 作任何改变; validateStudent只能够对其复件(副本)做修改。现在Student 以by reference 方式传递，将它声明为const 是必要的，因为不这样做的话调用者会忧虑validateStudent会不会改变他们传入的那个Student。

       以by reference方式传递参数也可以避免slicing ( 对象切割)问题。当一个derived class 对象以by value方式传递并被视为一个base class 对象， base class 的copy构造函数会别调用，而"造成此对象的行为像个derived class 对象"的那些特化性质全被切割掉了，仅仅留下一个base class 对象。这实在不怎么让人惊讶，因为正是base class 构造函数建立了它。但这几乎绝不会是你想要的。假设你在一组classes 上工作，用来实现一个图形窗口系统：

class Window {  
public:   
    ......  
    std::string name() const;    // 返回窗口名称  
    virtual void display() const;// 显示窗口和其内容  
};  
class WindowWithScrollBars: public Window {  
public:  
    ......  
    virtual void display{} const;  
};  

        现在假设你希望写个函数打印窗口名称，然后显示该窗口。下面是错误示范:

void printNameAndDisplay(Window w)// 不正确!参数可能被切割。  
{  
    std::cout << w.name();  
    w.display() ;  
} 

       当你调用上述函数并交给它一个WindowWithScrollBars 对象，会发生什么事呢?

WindowWithScrollBars wwsb;  
printNameAndDisplay(wwsb); 

        喔，参数W 会被构造成为一个Window对象:它是passed by value ，还记得吗?而造成wwsb" 之所以是个WindowWithScrollBars 对象"的所有特化信息都会被切除。在printNameAndDisplay 函数内不论传递过来的对象原本是什么类型，参数w 就像一个Window 对象(因为其类型是Window) 。因此在printNameAndDisplay 内调用display调用的总是Window::display，绝不会是WindowWithScrollBars::display。

       解决切割(slicing) 问题的办法，就是以by reference-to- const 的方式传递w:

void printNameAndDisplay(const Window& w)// 很好，参数不会被切割  
{  
    std::cout << w.name() ;  
    w.display();  
}  

        现在，传进来的窗口是什么类型，w 就表现出那种类型。
      如果窥视C++ 编译器的底层，你会发现， references往往以指针实现出来，因此pass by reference 通常意味真正传递的是指针。因此如果你有个对象属于内置类型(例如int) , pass by value 往往比pass by reference 的效率高些。对内置类型而言，当你有机会选择采用pass-by-value或pass-by-reference-to-const 时，选择pass-by-value并非没有道理。这个忠告也适用于STL 的选代器和函数对象，因为习惯上它们都被设计为passed by value。迭代器和函数对象的实践者有责任看看它们是否高效且不受切割问题(slicing problem) 的影响。
       内置类型都相当小，因此有人认为，所有小型types 都是pass-by-value的合格候选人，甚至它们是用户自定义的class 亦然。这是个不可靠的推论。对象小并不就意味其copy构造函数不昂贵。许多对象一一包括大多数STL 容器一一内含的东西只比一个指针多一些，但复制这种对象却需承担"复制那些指针所指的每一样东西"。那将非常昂贵。
       即使小型对象拥有并不昂贵的copy构造函数，还是可能有效率上的争议。某些编译器对待"内置类型"和"用户自定义类型"的态度截然不同，纵使两者拥有相同的底层表述(underlying representation) 。举个例子，某些编译器拒绝把只由一个double组成的对象放进缓存器内，却很乐意在一个正规基础上对光秃秃的doubles 那么做。当这种事发生，你更应该以by reference 方式传递此等对象，因为编译器当然会将指针(references的实现体)放进缓存器内，绝无问题。
       "小型的用户自定义类型不必然成为pass-by-value优良候选人"的另一个理由是，作为一个用户自定义类型，其大小容易有所变化。一个type 目前虽然小，将来也许会变大，因为其内部实现可能改变。甚至当你改用另一个C++ 编译器都有可能改变type的大小。举个例子，在我下笔此刻，某些标准程序库实现版本中的string 类型比其他版本大七倍。

       一般而言，你可以合理假设" pass-by-value 并不昂贵"的唯一对象就是内置类型和STL 的迭代器和函数对象。至于其他任何东西都请遵守本条款的忠告，尽量以pass-by-reference-to-const 替换passφy-value。

需要记住的
1.尽量以pass-by-reference-to-const替换pass-by-value。前者通常比较高效，并可避免切割问题(slicing problem) 。
2.以上规则并不适用于内置类型，以及STL 的迭代器和函数对象。对它们而言，pass-by-value往往比较适当。