条款20:宁以pass-by-reference-to-const替换pass-by-value

条款20:宁以pass-by-reference-to-const替换pass-by-value
        (Prefer pass-by-reference-to-const to pass-by-value.)

内容:
    先看一个例子,假设我们有一个Person类:
    class Person{
    public:
        Person(const string& name,const string& address)
        :name_(name),address_(address){
        };
        virtual ~Person(){}
        ...
    private:
        ...
        string name_;
        string address_;
    };
    现在有一个Student类继承Person类:
    class Student:public Person{
    public:
        Student(...){...}; //omit parameters for simplicity
        ~Student(){}
        ...
    private:
        ...
        string schoolName_;
        string schoolAddress_;
    };
    现在这里有一个函数函数要处理Person对象,其原型签名是这样:
    void queryPersonInfo(Person somebody);
    我们可以这样调用:
    ...
    Person firstPerson("michael scofield","New York");
    queryPersonInfo(firstPerson); // Label1
    Student firstStudent(...);
    queryPersonInfo(firstStudent); //Label2
    ...
    上面这段代码中由于queryPersonInfo函数传入参数是一个对象,那么参数传递中发生什么事情呢?C++默认的参数
传递方式是按值传递(pass-by-value),所谓按值传递就是函数调用过程中,产生了一个对象副本(调用该对象的copy构
造函数产生),该副本才被真正用来传递给目标函数的,函数对参数的所做的动作改变的都是对象副本而原对象没有发
生任何改变.
    如果我们用上面的参数传递方式,那么我们将有可能发生如下糟糕的事情:
    (1)如此的函数调用会带来效率问题.如label1代码中,对象副本的产生过程也是新对象local成员变量的产生过程
(name_,address_,schoolName_,schoolAddress_四个对象发生拷贝构造),哦欧,没想到吧,仅仅的一个参数传递方式付
出了如此高的代价,如果你的代码中一直都用的是这种参数传递方式,那么你的程序效率将大打折扣.
    (2)可能会发生"对象切割"(object slicing)现象.如label2代码中,函数原型中参数类型是Person,而这里你却传入
一个类型为Student对象,由于它们之间的继承关系的作用,编译器可以把firstStudent当做一个Person来处理,这样的
话,firstStudent的base class将被以pass-by-value进行传递,(1)所述将调用base class的copy构造函数创建原对象
副本传入目标函数,而firstStudent具有的derived class的那些特性将被完全切割掉,仅仅留下一个base class,oh
no,这太吓人了,这不是我想要的结果.
    为了避免上述两种情况出现,我们改变一下函数原型:
    void queryPersonInfo(const Person& thePerson);
    这种参数传递方式称之为pass-by-reference-to-const,这种方式在传递过程中不会有对象副本的拷贝构造发生,
它传过去的就是原对象本身的引用,底层实现上,引用是通过指针来实现的,也就是传递过去的是原对象的指针,而(2)
的情况也不会发生,因为引用或指针对象的参数可以引起多态性行为,也就是解决了"对象分割"引起的问题.通过下面这个
例子我们就能够更加清楚的理解这一点.
    这里我们有一个图形窗口系统Window类:
    class Window{
    public:
        ...
        std::string name()const;     //返回窗口名称
        virtual void display()const; //显示窗口和它的内容
    };
    假设这里有它的一个子类WindowWithScrollBars,它是带有滚动条的窗口系统:
    class WindowWithScrollBars:public Window{
    public:
        ...
        virtual void display()const;
    };
    这里有个函数用来打印窗口名称,然后显示该窗口,我们先用pass-by-value进行函数原型设计:
    void printNameAndDisplay(Window win){ //critical warning: object-slicing 
        std::cout<<win.name();
        w.display();
    }
    我们来调用它:
    WindowWithScrollBars windowbar;
    printNameAndDisplay(windowbar);
    上面这行代码就有可能发生对象分割(当然产生对象副本),这里传入的windowbar对象的WindowWithScrollBars
的特化信息都会被切除,那么该函数输出的窗口名称就是base class的name,不是windowbar的名称,即该函数实际调
用的display版本为子类Window::display,而不是WindowWithScrollBars::display.
    我们再用pass-by-reference-to-const进行函数原型设计:
    void printNameAndDisplay(const Window& win){
        ...//同上
    }
    调用该函数的代码也不变.这里参数传进来的对象是哪种类型,该函数就调用那个类型的display版本,这里调用
的是WindowWithScrollBars::display.
    那么我们何时使用pass-by-value方式,何时使用pass-by-reference-const方式进行参数传递呢?大多数人都采
用这样一个不成文的约定:对于内置型对象(如int),STL迭代器以及函数对象使用pass-by-value,而对于自定义类对
象则采用pass-by-reference-const的方式进行参数传递.
    好了,今天我们就讨论到这里.
   
    请记住:
    ▲ 尽量以pass-by-reference-to-const替换pass-by-value.前者通常比较高效,并可避免切割问题(slicing
problem).
    ▲ 以上规则并不适合与内置类型,以及STL的迭代器和函数对象.对它们而言,pass-by-value往往比较适合.