C++条款宁以pass-by-reference-to-const替换pass-by-value 11/55

最新推荐文章于 2024-07-21 23:09:42 发布

MisakiJh

最新推荐文章于 2024-07-21 23:09:42 发布

阅读量204

点赞数

分类专栏： C++条款

本文链接：https://blog.csdn.net/MisakiJh/article/details/89002408

版权

C++条款专栏收录该内容

13 篇文章 2 订阅

订阅专栏

宁以pass-by-reference-to-const替换pass-by-value

Prefer pass-by-referenct-to-const to pass-by-value

缺省情况下C++以by value方式传递对象至（或来自）函数。除非你另外指定，否则函数参数都是以实际实参文件的复件为初值，而调用端所获得的亦是函数返回值的一个复件。这些复件由对象的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实参并返回它是否有效：

bool validataStudent(Student s);
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构造动作又需承担两个string构造动作。最终结果是，以by value方式传递一个Student对象会导致调用一次Student copy构造函数、一次Person copy构造函数、四次string copy构造函数。再把销毁考虑上，总体成本是“六次构造函数和六次析构函数”。

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

bool validateStudent(const Student& s);

这个传递方式效率高得多：没有任何构造函数和析构函数被调用。这个const是重要的。原本以by value方式传递的原意就是函数内不会对传入的Student作任何改变，只能够对其复件做修改。现在Student以by reference方式传递，将它声明为const就保持了原意。

以by reference方式传递参数也可以避免slicing（对象切割）问题。当一个derived class对象以by value方式传递并被视为一个base class对象，base class的copy构造函数会被调用，而“造成此对象的行为像个derived class对象”的那些特化性质全被切割掉了，仅仅留下一个base class对象，因为正式base class构造函数建立了它。但这几乎绝不会是你想要的。假设你在一组classes上工作，用来实现一个图形窗口系统：

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 printNameAndDisplay(Window w)    //不正确，参数可能被切割
{
    std::cout<<w.name();
    w.display();
}

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

WindowWithScrollBars wwsb;
printNameAndDisplay(wwsb);

w会被构造成为一个Window对象；它是passed by value，你还记得吗？而造成wwsb“是个WindowWithScrollBars对象”的所有特化信息都会被切除。在printNameAndDisplay内调用display调用的总是Window::display，绝不会是WindowWithScrollBars::display。

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

void printNameAndDisplay(const Window& w)    //很好，参数不会被切割
{
    std::cout<<w.name();
    w.display();
}

现在，传进来的窗口是什么类型，w就表现出那种类型。

当你有机会选择采用pass-by-value或pass-by-reference-to-const时，选择pass-by-value并非没有道理。因为你有个对象属于内置类型，pass by value往往比pass by reference的效率高些。这个忠告也适用于STL的迭代器和函数对象，因为习惯上它们都被设计为passed by value。

内置类型都非常小，因此有人认为，所有小型types都是pass-by-value的合格候选人，甚至它们是用户自定义的class亦然。这是个不可靠的推论。对象小并不就意味着其copy构造函数不昂贵。许多对象——包括大多数STL容器——内含的东西只比一个指针多些，但复制这种对象却需承担“复制那些指针所指的每一样东西”。那将非常昂贵。

即使小型对象拥有并不昂贵的copy构造函数，还是可能有效率上的争议。某些变编译器对待“内置类型”和“用户自定义类型”的态度截然不同，纵使两者拥有相同的底层表述。举个例子，某系变编译器拒绝把只由一个double组成的对象放进缓存器内，却很乐意在一个正规基础上对光秃秃的doubles那么做。当这种事发生，你更应该by reference方式传递此等对象，因为编译器当然会将指针放进缓存器内，绝无问题。

“小型的用户自定义类型不一定非要成为pass-by-value优良候选人”的另一个理由是，作为一个用户自定义类型，其大小容易有所变化。一个type目前虽然小，将来也许会变大，因为其内部实现可能改变。

一般而言，你可以合理假设“pass-by-value并不昂贵”的唯一对象就是内置类型和STL的迭代器和函数对象。至于其他任何东西都尽量以pass-by-referenct-to-const替换pass-by-value。

总结：

尽量以pass-by-referenct-to-const替换pass-by-value。前者通常比较高效，，并可避免切割问题。(slicing problem)
以上规则并不适用于内置类型，以及STL的迭代器和函数对象。对它们而言，pass-by-value往往比较适当

编于04/03/2019 21:01