C 箴言：用传引用给const取代传值

　　缺省情况下，C 以传值方式将对象传入或传出函数（这是个从 C 继承来的特性）。除非您特别指定其他方式，否则函数的参数就会以实际参数（actual argument）的拷贝进行初始化，而函数的调用者会收到函数返回值的一个拷贝。这个拷贝由对象的拷贝构造函数生成。这就使得传值（pass-by-value）成为一个代价不菲的操作。例如，考虑下面这个类层级结构：

class Person {
　public:
　　Person(); // parameters omitted for simplicity
　　virtual ~Person(); // see Item 7 for why this is virtual
　　...

　private:
　　std::string name;
　　std::string address;
};

class Student: public Person {
　public:
　　Student(); // parameters again omitted
　　~Student();
　　...

　private:
　　std::string schoolName;
　　std::string schoolAddress;
};

　　现在，考虑以下代码，在此我们调用一个函数—— validateStudent，他得到一个 Student 参数（以传值的方式），并返回他是否验证有效的结果：

bool validateStudent(Student s); // function taking a Student
// by value

Student plato; // Plato studied under Socrates

bool platoIsOK = validateStudent(plato); // call the function

　　当这个函数被调用时会发生什么呢？

　　很明显，Student 的拷贝构造函数被调用，用 plato 来初始化参数 s。同样明显的是，当 validateStudent 返回时，s 就会被销毁。所以这个函数的参数传递代价是一次 Student 的拷贝构造函数的调用和一次 Student 的析构函数的调用。

　　但这还不是全部。一个 Student 对象内部包含两个 string 对象，所以每次您构造一个 Student 对象的时候，您也必须构造两个 string 对象。一个 Student 对象还要从一个 Person 对象继承，所以每次您构造一个 Student 对象的时候，您也必须构造一个 Person 对象。一个 Person 对象内部又包含两个额外的 string 对象，所以每个 Person 的构造也承担着另外两个 string 的构造。最终，以传值方式传递一个 Student 对象的后果就是引起一次 Student 的拷贝构造函数的调用，一次 Person 的拷贝构造函数的调用，连同四次 string 的拷贝构造函数调用。当 Student 对象的拷贝被销毁时，每一个构造函数的调用都对应一个析构函数的调用，所以以传值方式传递一个 Student 的全部代价是六个构造函数和六个析构函数！

　　好了，这是正确的和值得的行为。毕竟，您希望您的全部对象都得到可靠的初始化和销毁。尽管如此，假如有一种办法能够绕过任何这些构造和析构过程，应该变得更好，这就是：传引用给 const（pass by reference-to-const）：

bool validateStudent(const Student& s);

　　这样做很有效：没有任何构造函数和析构函数被调用，因为没有新的对象被构造。被修改的参数声明中的 const 是很重要的。 validateStudent 的最初版本接受一个 Student 值参数，所以调用者知道他们屏蔽了函数对他们传入的 Student 的任何可能的改变；validateStudent 也只能改变他的一个拷贝。现在 Student 以引用方式传递，同时将他声明为 const 是必要的，否则调用者必然担心 validateStudent 改变了他们传入的 Student。

　　以传引用方式传递参数还能够避免切断问题（slicing problem）。当一个派生类对象作为一个基类对象被传递（传值方式），基类的拷贝构造函数被调用，而那些使得对象的行为像一个派生类对象的特别特性被“切断”了。您只剩下一个纯粹的基类对象——这没什么可吃惊的，因为是个基类的构造函数创建了他。这几乎绝不是您希望的。例如，假设您在一组实现一个图像窗口系统的类上工作：

class Window {
　public:
　　...
　　std::string name() const; // return name of window
　　virtual void display() const; // draw window and contents
};

class WindowWithScrollBars: public Window {
　public:
　　...
　　virtual void display() const;
};

　　任何 Window 对象都有一个名字，您能通过 name 函数得到他，而且任何的窗口都能够显示，您可一个通过调用 display 函数来做到这一点。display 为 virtual 的事实清楚地告诉您：一个纯粹的基类的 Window 对象的显示方法有可能不同于专门的 WindowWithScrollBars 对象的显示方法。

　　现在，假设您想写一个函数打印出一个窗口的名字，并随后显示这个窗口。以下这个函数的写法是错误的：

void printNameAndDisplay(Window w) // incorrect! parameter
{
　// may be sliced!
　std::cout << w.name();
　w.display();
}

　　考虑当您用一个 WindowWithScrollBars 对象调用这个函数时会发生什么：

WindowWithScrollBars wwsb;

printNameAndDisplay(wwsb);

　　参数 w 将被作为一个 Window 对象构造——他是被传值的，记得吗？而且使 wwsb 表现得像一个 WindowWithScrollBars 对象的特别信息都被切断了。在 printNameAndDisplay 中，全然不顾传递给函数的那个对象的类型，w 将始终表现得像一个 Window 类的对象（因为他就是个 Window 类的对象）。特别是，在 printNameAndDisplay 中调用 display 将总是调用 Window::display，绝不会是 WindowWithScrollBars::display。

　　绕过切断问题的方法就是以传引用给 const 的方式传递 w：

void printNameAndDisplay(const Window& w) // fine, parameter won’t
{
　// be sliced
　std::cout << w.name();
　w.display();
}

　　现在 w 将表现得像实际传入的那种窗口。

　　假如您掀开编译器的盖头偷看一下，您会发现用指针实现引用是很典型的做法，所以以引用传递某物实际上通常意味着传递一个指针。由此能够得出结论，假如您有一个内建类型的对象（例如，一个 int），以传值方式传递他常常比传引用方式更高效。那么，对于内建类型，当您需要在传值和传引用给 const 之间做一个选择时，没有道理不选择传值。同样的建议也适用于 STL 中的迭代器（iterators）和函数对象（function objects），因为，作为惯例，他们就是为传值设计的。迭代器（iterators）和函数对象（function objects）的实现有责任确保拷贝的高效并且不受切断问题的影响。（这是个“规则如何变化，依赖于您使用 C 的哪一个部分”的实例。）

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有