C++之宁以pass-by-reference-to-const替换pass-by-value（20）---《Effecitive C++》

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

缺省情况下C++以by value方式（一个继承自C的方式）传递对象至（或来自）函数。除非你另外指定，否则函数参数都是以实际实参的复件为初值，调用端获得的亦是函数返回值的一个复件。复件（副本）的产生需要花费时间，浪费资源，参看如下代码。

#include <iostream>
#include <string>
using namespace std;
class Base{
public:
    Base(){
        cout << "=====Base的构造函数=====" << endl;
    }
    Base(int aa, int bb) :a(aa), b(bb){
        cout << "=====Base的构造函数=====" << endl;
    }
    virtual void show()const{
        cout << a << " " << b << endl;
    }
    virtual ~Base(){
        cout << "=====Base的析构函数=====" << endl;
    }
private:
    int a;
    int b;
};
class Derived :public Base{
public:
    Derived(){
        cout << "=====Derive的构造函数=====" << endl;
    }
    Derived(int a, int b):Base(a,b){
        cout << "=====Derive的构造函数=====" << endl;
    }
    virtual void show()const {
        cout << "子类Derived函数中的show()" << endl; 
        Base::show();
    }
    virtual ~Derived(){
        cout << "=====Derive的析构函数=====" << endl;
    }
};
void hello(Base b){
    cout << endl;
    cout << "=====hello=====" << endl;
    b.show();
    cout << "---------------" << endl;
}

int main(){
    Base b(1, 2);
    hello(b);
    return 0;
}

运行结果如下：

可以发现Base析构函数执行了两次，其实其构造函数也执行了两次，因为通过值传递的过程中，我们可以发现，没进行一次值的copy就进行了一次值的copy过程，因此，在函数结束的时候析构函数自动执行，需要析构两个函数，因此需要析构两个对象，因此出现了两个析构函数；
可以看到上面的这种行为需要对参数进行拷贝，浪费资源，同时又降低了程序执行的效率！

那么我们有什么方法可以避免这种问题呢？ 当然有的，就是pass by reference-to-const： 这种方式有两种优点：

1）极大提高了程序的执行效率，没有任何构造函数或者析构函数被调用，因为没有任何新对象被创建，一般我们传递的时候应该声明为const变量，这样会保证传递进去的引用变量不会被修改； 2）用pass-by-reference凡是传递参数也可以避免slicing（对象切割）问题。当一个derived class对象通过pass-by-name方式传递的时候被视为一个base class对象，base class的copy构造函数会被调用，导致“对象的行为向derived class对象”的那些特性全被切割掉了，仅仅留下一个base class对象，这种坑让程序开发者陷入深入思考却不知道错在哪里，因此我们推荐使用pass-by-reference-const进行参数传递，参看如下代码：

#include <iostream>
#include <string>
using namespace std;
class Base{
public:
    Base(){

    }
    Base(int aa, int bb) :a(aa), b(bb){
    }
    virtual void show()const{
        cout << a << " " << b << endl;
    }
    virtual ~Base(){
    }
private:
    int a;
    int b;
};
class Derived :public Base{
public:
    Derived(){

    }
    Derived(int a, int b):Base(a,b){
    }
    virtual void show()const {
        cout << "子类Derived函数中的show()" << endl; 
        Base::show();
    }
    virtual ~Derived(){
    }
};
void hello(Base b){
    cout << endl;
    cout << "=====hello=====" << endl;
    b.show();
    cout << "---------------" << endl;
}
void hello2(const Base& b){
    cout << endl;
    cout << "=====hello2=====" << endl;
    b.show();
    cout << "---------------" << endl;
}
void hello3(Base* b){
    cout << "=====hello3=====" << endl;
    b->show();
    cout << "---------------" << endl;
}
int main(){
    Derived d(1, 2);
    hello(d);
    hello2(d);
    Base* b = new Derived(2, 3);
    hello3(b);
    delete b;
    return 0;
}

运行结果：

这里有一个逻辑坑，内置类型一般通过pass-by-value传递，因为pass-by-reference实际是通过指针传递的，对于内置类型而言，pass-by-value显然效率高一些，同时，内置类型的结构比较小，因此有的人想当然的认为小型types都是pass-by-value传递，甚至它们是用户自定义的class也无所谓，这个结论是错误的！因为有不同的类，同时编译器有不同的工作方式，因此，明智的选择是尽量采用pass-by-reference-const传递，但有特例，对于内置类型、STL的迭代器和函数对象，使用pass-by-value可能效率高一些！
总结：
1）尽量使用pass-by-reference-to-const替换pass-by-value，前者通常比较高效率，并可以避免对象切割问题；
2）以上规则并不适用于内置类型、STL迭代器和函数对象，对他们而言，pass-by-reference往往比较适当！

PS：
1、C++内置类型
算数类型：字符、整数、bool、浮点；
空类型：void。
2、C++STL迭代器：
包括Input iterator、Output iterator、Forward iterator、Bidirectional iterator、Random access iterator这5中迭代器。
3、C++函数对象：

class A{
public:
    A();
    ...
    int operator()(int x){
        return x;
    }
private:
    int x;
};
A a(5);
a(10);

此时，a(10)就是函数对象，类似于这种的都是函数对象。