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

探讨C++中对象传递的成本,对比值传递与引用传递的效率,解析对象切割问题及解决方案,推荐使用const引用传递提高性能。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

        缺省(默认)情况下C++以by value方式(一个继承自C的方式)传递对象至(或来自)函数。除非你另外指定,否则函数参数都是以实际实参的复件(副本)为初值,而调用端所获得的亦是函数返回值的一个复件。这些复件(副本)系由对象的copy构造函数产出,这可能使得pass-by-value成为昂贵的(费时的)操作。考虑一下class继承体系:

class Person {
public:
    Persion();             // 为求简化,省略参数
    virtual ~Persion();    // 条款7告诉你为什么它是virtual
    ...
private:
    std::string name;
    std::string address;
};

class Student: public Persion {
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对象又有两个string对象在其中,因此每一次Person构造动作又需要承担两个string构造动作。最终结果是,以by value方式传递一个Student对象会导致调用一次Student copy构造函数、一次Person copy构造函数、四次string copy构造函数。当函数内的那个Student复件被销毁,每一个构造函数调用动作都需要一个对应的析构函数调用动作。因此,以by value方式传递一个Student对象,总体成本是“六次构造函数和六次析构函数”!

        上述方式尽管正确,但要是能避免所有那些构造和析构动作就太好了。有的,就是pass bu 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对象。这实在不怎么让人惊讶,因为正是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对象的显示方式和华丽高贵的WindowWithhScrollBars对象的显示方式不同(见条款34和条款36)。

        现在假设你希望写个函数打印窗口名称,然后显示该窗口。下面是错误示范:

void printNameAndDisplay(Window w)      // 不正确!参数可能被切割。
{
    std::cout << w.name();
    w.display();
}

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

WindowWithScrollBars wwsb;
printNameAndDisplay(wwsb);

        参数w会被构造成为一个Window对象;它是passed by value,还记得吗?而造成wwsb“之所以是个WindowWithScrollBars对象”的所有特化信息都会被切除。在printNameAndDisplay函数内不论传递过来的对象原本是什么类型,参数w就像一个Window对象(因为其类型是Window)。因此在printNameAndDisplay内调用display调用的总是Window::display,绝不会是windowWithScrollBars::display。

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

void printNameAndDisplay(Window& w)      // 正确!参数不会被切割。
{
    std::cout << w.name();
    w.display();
}

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

        如果窥视C++编译器的底层,你会发现,references往往以指针实现出来,因此pass by reference通常意味真正传递的是指针。因此如果你有个对象属于内置类型(例如int),pass by value往往比pass by reference的效率高些。对内置类型而言,当你有机会选择采用pass-by-value或pass-by-reference-to-const时,选择pass-by-value并非没有道理。这个忠告也适用于STL的迭代器和函数对象,因为习惯上它们都被设计为passed by value。

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

请记住

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

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值