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

首先解释一下这个标题的意思吧，就是使用引用传参来替换传值传参，因为传值传参相比传引用来说有着太多的不方便，下面我来详细说明一下理由

1.理由1.使用by value会产生很多麻烦的过程（比如调用拷贝构造函数等一系列不必要的函数），看如下代码

int n = 0;
class String
{
public:
	String()
	{
		n++;
		cout << "String::构造函数  n="<<n << endl;
		
	}
	String(const String& s)
	{
		n++;
		cout << "String::拷贝构造函数 n=" << n << endl;
	}
	virtual ~String()
	{
		n++;
		cout << "String::析构函数 n=" << n << endl;
	}
};
class Base
{
public:
	Base()
	{
		n++;
		cout << "Base::构造函数 n=" << n << endl;
	}
	Base(const Base& s)
		:name(s.name)
		,address(s.address)
	{
		n++;
		cout << "Base::拷贝构造函数 n=" << n << endl;
	}
	virtual ~Base()
	{
		n++;
		cout << "Base::析构函数 n=" << n << endl;
	}
private:
	String name;
	String address;
};
class Dervice :public Base
{
public:
	Dervice()
	{
		n++;
		cout << "Dervice::构造函数 n=" << n << endl;
	}
	Dervice(const Dervice& s) :Base(s), Derviceddress(s.Derviceddress), Dervicename(s.Dervicename)
	{
		n++;
		cout << "Dervice::拷贝构造函数 n=" << n << endl;
	}
	virtual ~Dervice()
	{
		n++;
		cout << "Dervice::析构函数 n=" << n << endl;
	}
private:
	String Dervicename;
	String Derviceddress;
};
bool validata(Dervice s)
{
	return 0;
}
void test()
{
	Dervice ww;
	cout << "****************************************" << endl;
	bool n = validata(ww);
}
int main()
{
	test();
	system("pause");
	return 0;
}

这是一个by-value的方式传参的函数的调用validata函数。
所以在这里首先1.调用Dervice的拷贝构造函数以ww为蓝本将s初始化，同样的在validata函数结束以后s会被销毁，调用Dervice的析构函数。当然这只是大概的基本调用，事情往往没那么简单，就上面的这个例子来看，因为每个类的成员也都是一个string 类型的。

所以上面完整的调用函数是1.调用Dervice的拷贝构造函数，2.调用Base的拷贝构造函数，3.调用Base中的第一个string的拷贝构造函数，4.调用Base中的第二个string的拷贝构造函数，5.调用Dervice的第一个string的拷贝构造函数，6，调用Dervice的第二个string的拷贝构造函数。当validata调用结束以后销毁s的时候又分别调用对应的析构函数。

这样看来传值是不是非常的恶心中间要调用这么多次函数，效率相对来说肯定是比较低的，

所以如果我们以引用的方式来传参，那么将会简单的很多

bool validata(Dervice &s)
{
	return 0;
}
void test()
{
	Dervice ww;
	cout << "****************************************" << endl;
	bool n = validata(ww);
}

但是在这里提醒一点函数的形参应该加上const修饰

bool validata(const Dervice &s)
{
	return 0;
}

上面的演示我没有加，为什么要加这个const,因为之前以值传递的方式传递过去的是ww的副本，函数内部不会对main中的ww做任何改变，改变的只是ww在validata中的副本,但是现在传递形式是引用传递，如果不声明为const的话，在validata中更改的话相当于更改了main中的ww.

这为什么要用引用而不用值传递的理由1，下面我来阐述理由二

2.使用引用传递会避免对象切割问题

首先对象切割是什么呢？

解释：我用代码来说明吧

class Base
{
public:
	virtual void fun()
	{
		cout << "Base:;fun" << endl;
	}
	Base()
	{}
	Base(Base & s)
	{
		cout << "Base::拷贝构造函数" << endl;
	}
};
class Dervice :public Base
{
public:
	virtual void fun()
	{
		cout << "Dervice:;fun" << endl;
	}
	Dervice()
	{}
	Dervice(Dervice &s) :Base(s)
	{
		cout << "Base::拷贝构造函数" << endl;
	}
};
void test(Dervice s)
{
	s.fun();
}
int main()
{
	Dervice ww;
	test(ww);
	system("pause");
	return 0;
}

上述就是一个对象切割的例子.

一个在继承中，当一个Dervice对象以传值的方式传递并且接受他的为形参为Base类型的话，那么这个时候Base的拷贝构造函数就会被调用，而不是Dervice的拷贝构造函数被调用，这样就会造成Dervice对象的特性全部被切割掉了，仅仅留下一个Base对象的特性，这就是对象切割，所以在Test中调用fun的话，只会调用基类对象的函数。而绝不会调用派生类的函数。

这个时候使用引用传递的方式就可以解决这个问题。

void test(Base& s)
{
	s.fun();
}
int main()
{
	Dervice ww;
	test(ww);
	system("pause");
	return 0;
}

现在传进来什么类型，w就表现哪种类型。

这就解决了对象切割的问题！

最后要说的就是：

当对象为内置类型或者STL的迭代器和函数对象，可以考虑使用传值的方式，否则的话尽量采用引用传值的方式！