[翻译] Effective C++, 3rd Edition, Item 20: 用 pass-by-reference-to-const（传给 const 引用）取代 pass-by-value（传值）（上）

Item 20: 用 pass-by-reference-to-const（传 const 引用）取代 pass-by-value（传值）

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.youkuaiyun.com/fatalerror99/

缺省情况下，C++ 以 by value（传值）方式将 objects 传入或传出函数（这是一个从 C 继承来的特性）。除非你特别指定其它方式，否则 function parameters（函数形参）就会以 copies of the actual arguments（当前实参的拷贝）进行初始化，而且函数的调用者会取回函数返回值的一个 copy（拷贝）。这些拷贝由 objects 的 copy constructors（拷贝构造函数）生成。这就使得 pass-by-value（传值）成为一个代价不菲的操作。例如，考虑如下 class hierarchy（类继承体系）：

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
  virtual ~Student();
  ...

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

（原文并没有显式声明 Student destructor 为 virtual，根据作者网站勘误修改——译者注。）

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

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

Student plato;                             // Plato studied under Socrates

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

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

很明显，Student copy constructor（拷贝构造函数）被调用，用 plato 来初始化 parameter（形参）s。同样明显的是，当 validateStudent 返回时，s 就会被销毁。所以这个函数的 parameter-passing cost（参数传递成本）是一次 Student copy constructor（拷贝构造函数）的调用和一次 Student destructor（析构函数）的调用。

但这还不是全部。一个 Student object 内部包含两个 string objects，所以每次你构造一个 Student object 的时候，你也必须构造两个 string objects。一个 Student object 还要从一个 Person object 继承，所以每次你构造一个 Student object 的时候，你也必须构造一个 Person object。一个 Person object 内部又包含另外两个 string objects，所以每个 Person 的构造也承担着另外两个 string 的构造。最终，以 by value（传值）方式传递一个 Student object 的后果就是导致一次 Student copy constructor（拷贝构造函数）的调用，一次 Person copy constructor（拷贝构造函数）的调用，以及四次 string copy constructor（拷贝构造函数）调用。当 Student object 的拷贝被销毁时，每一次 constructor call（构造函数调用）都有一次 destructor call（析构函数调用）对应，所以以 by value（传值）方式传递一个 Student 的全部成本是六次 constructors（构造函数）和六次 destructors（析构函数）！

好了，这是正确的和值得的行为。毕竟，你想要你的所有 objects 都得到可靠的初始化和销毁。尽管如此，如果有一种办法可以绕过所有这些构造和析构过程，那就更好了，这就是：pass by reference-to-const（传 const 引用）：

bool validateStudent(const Student& s);

这样做非常有效：没有 constructors（构造函数）和 destructors（析构函数）被调用，因为没有新的 objects 被创建。被修改的 parameter declaration（形参声明）中的 const 是非常重要的。validateStudent 的最初版本以 by value（传值）方式取得一个 Student parameter（形参），所以调用者知道它们屏蔽了函数对它们传入的 Student 的任何可能的改变；validateStudent 只能改变它的一个 copy（拷贝）。现在 Student 以 by reference（传引用）方式传递，将它声明为 const 也是必要的，否则调用者必然担心 validateStudent 改变了它们传入的 Student。

以 by reference（传引用）方式传递 parameter（形参）还可以避免 slicing problem（切断问题）。当一个 derived class object（派生类对象）作为一个 base class object（基类对象）（以传值）方式被传递，base class copy constructor（基类拷贝构造函数）被调用，而那些使得 object 的行为像一个 derived class object（派生类对象）的特殊特性被 "sliced"（“切断”）了。只给你留下一个 simple base class object（纯粹基类对象）——这没什么可吃惊的，因为是一个 base class constructor（基类构造函数）创建了它。这几乎绝不是你想要的。例如，假设你在一组实现一个图形窗口系统的 classes 上工作：

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 objects 都有一个名字，你能通过 name 函数得到它，而且所有的窗口都可以显示，你可一个通过调用 display 函数来做到这一点。display 为 virtual（虚拟）的的事实告诉你：一个 simple base class（纯粹基类）的 Window objects 的显示方法有可能不同于专门的 WindowWithScrollBars objects 的显示方法（参见 Items 34 和 36）。

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

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

考虑当你用一个 WindowWithScrollBars object 调用这个函数时会发生什么：

WindowWithScrollBars wwsb;

printNameAndDisplay(wwsb);

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

绕过 slicing problem（切断问题）的方法就是以 by reference-to-const（传 const 引用）方式传递 w：

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

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

（本篇未完，点击此处，接下篇）