Effective C++ 学习笔记（十五）

缺省情况下C++以by  value方式（一个继承自C的方式）传递对象至（或来自）函数。

除非你另外指定，否则函数参数都是以实际实参的复件（副本）为初值，而调用端所获得的亦是函数返回值的一个复件。

这些复件（副本）系由对象的copy构造函数产出，这可能使pass-by-value成为昂贵（费时的)操作。

class Person{

 public:

   Person();

   virtual ~Person();

private:

    std::string name;

    std::string address;

};

class Student :public Person{

public:

     Student();

   ~Student();

private:

     std::string  schoolName;

     std::string   schoolAddress;

}

现在考虑以下代码，其中调用函数validateStudent,后者需要一个Student实参（by value)并返回他是否有效：

bool  validateStudent(Student s);                     //函数以by value方式接受学生

Student plato;                                                   //柏拉图，苏格拉底的学生

bool  platoIsOk=validateStudent(plato);          //调用函数

无疑地Student的copy构造函数会被调用,以plato为蓝本将s初始化。

同样明显地，当validateStudent返回s会被调用。因此，参数的传递成本是“因此Student copy构造函数调用，加上一次Student析构函数调用”.

Student对象内有两个string对象，所以每次构造一个Student对象也就构造了两个string对象。此外Student对象继承自Person对象，所以每次构造Student对象也就必须

一个person对象。一个person对象又有两个string对象在其中，因此每一次person构造动作又需承担两个sttring构造动作。最终结果是，以by value方式传递一个student

构造出一个Person对象。一个Person对象又有两个string对象在其中，因此每一次Person构造动作又需承担两个string构造动作。

最终结果是，以by value方式传递一个Student对象会导致调用一次Student copy构造函数，一次Person copy构造函数，四次string copy构造函数。

当函数内的那个Student复件被销毁，每一个够着函数调用动作都需要一个对应的析构函数调用动作。

因此，以by value方式传递一个student对象，总体成本是“六次构造函数和六次析构函数”

如果有什么方法可以回避所有那些构造和析构动作就太好了，有的，那就是pass by  reference-to-const:

 bool validateStudent(const Student&  s);

这种传递方式的效率高很多：没有任何构造函数或析构函数被调用，因为没有任何新对象被创建。

修订后的这个参数声明中的const是最重要的原先的validateStudent以by value方式接受一个Student参数，因此调用者知道他们受到保护，

函数内绝不会对传入的Student做任何改变，validateStudent只能够对其复件（副本）做修改。现在Student以by reference方式传递，将它声明为const

是必要的，因为不这样做得话调用者会忧虑validateStudent会不会改变他们传入的那个Student。

以by reference方式传递参数也可以避免slicing(对象切割）问题。当一个derived class对象以by value方式传递并被视为base class 对象，base class

的copy构造函数会被调用，而“造成此对象的行为像个derived class 对象”的那些特化性质全被切割掉了，仅仅留下了一个base class对象。

class Window{

public:

    std::string name() const;    //返回窗口名称

     virtual void display() const; //显示窗口和其内容

};

class WindowWithScrollBars:public Window{

public:

     virtual void display() const;

};

所有Window对象都带有一个名称，你可以通过name函数取得它。所有窗口都可以显示，你可以通过display函数完成它。

display是个virtual函数，这意味简易朴素的base class window对象的显示方法和华丽高贵的windowWithScrollBars对象的显示

方法不同

假设你希望写出个函数打印窗口名称，然后显示该窗口。

void printNameDisplay(Window w)

{

    std::cout<<w.name();

    w.display();

}

当你调用上述函数并交给它一个windowWithScrollBars对象会发生什么事呢？

WindowWithScrollBars wwsb;

printNameAndDisplay(wwsb);

参数w会被构造成为一个Window对象，它是pass by value

而造成wwsb之所以是个windowWithScrollBars对象的所有特化信息都会被切除。

在printNameAndDisplay函数内不论传递过来的对象原来是什么类型，参数w就像一个window对象（因为其类型时window)

因此在printNameAndDisplay内调用display调用的总是Window::display,绝不会是WindowWithScrollBars::display.

解决切割(slicing)问题的办法，就是以by reference-to-const的方法传递w：

void  printNameAndDisplay(const Window& w)

{

     std::cout<<w.name();

     w.display();

}

如果窥视C++编译器的底层，你会发现,reference往往以指针实现出来，因此 pass by reference 通常意味着真正传递的是指针。

因此如果你有内置类型（如int)pass by value往往比pass by reference的效率高些

一般而言，你可以合理假设"pass -by-value并不昂贵"的唯一对象就是内置类型和STL的迭代器和函数对象。至于其他任何东西都请遵守本条款的忠告，

尽量以pass-by-reference-to-const 替换pass-by-value.