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 &l
13c72
t;< "---------------" << 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)就是函数对象，类似于这种的都是函数对象。