【C++】拷贝对象时,编译器的偷偷优化

你知道吗?对于连续的”构造+拷贝构造“,编译器其实是会默默做出优化的。👻

如果你不知道这个知识点的话,那下面这道笔试题就要失分了😵。

本篇分享一个关于编译器优化的小知识,看完本篇,你就能知道程序里的 构造函数、拷贝构造函数 究竟被调了几次~

题目引入

某笔试题:下面的程序经历了几次构造?几次拷贝构造?

答案为:

1次构造,4次拷贝

对此题的分析在本篇末尾。如果你对这道题尚有存疑,那相信看完本篇,你的疑惑将会烟消云散~👻

传值传参 的优化

我们知道,传值传参会产生拷贝,因为这样能保证 函数内部对参数的操作 不会影响到原始变量的值。

➡️先看一个没做优化的例子:

class W
{
public:
    //构造函数
    W(int w) 
        :_w(w)
    {
        cout << "W()" << endl;
    }
    //拷贝构造函数
    W(const W& w) 
    :_w(w._w)
    {
        cout << "W(const W& w)" << endl;
    }
    //析构函数
    ~W(){
        cout << "~W()" << endl;
    }
private:
    int _w;
};
void func(const W w) {
    
}
int main()
{
    W w1=1;  //构造
    func(w1);   //拷贝构造:把w1的值拷贝一份,传到形参
    return 0;
}

调用情况我们打印出来:

可见这种情况下:

W w1=1;
func(w1);

是老老实实调用构造+拷贝构造的,并没有做出优化。

➡️再看一个做了优化的例子:

class W
{
public:
    //构造函数
    W(int w) 
        :_w(w)
    {
        cout << "W()" << endl;
    }
    //拷贝构造函数
    W(const W& w) 
    :_w(w._w)
    {
        cout << "W(const W& w)" << endl;
    }
    //析构函数
    ~W(){
        cout << "~W()" << endl;
    }
private:
    int _w;
};
void func(const W w) {
    
}
int main()
{
    func(W(1));  //一个表达式步骤中,有连续的”构造+拷贝构造“
    return 0;
}

结果:

我们发现:这次没调拷贝构造了!看来编译器做了优化。

原本,这个表达式的执行顺序是:W(1)先构造出一个W,这个W再拷贝构造,传递给形参,参与表达式func()。

func(W(1));

而编译器做出了优化:

将连续的 构造+拷贝构造 优化成一步构造。

动图可以更直观地看出来:

传匿名对象 的优化

我们学过的匿名对象,也是可以传参过去的,它的优化和刚刚讲的传值传参的优化 道理是一样的。

class W
{
public:
    W() {
        cout << "W()" << endl;
    }
    W(const W& w) {
        cout << "W(const W& w)" << endl;
    }
    ~W(){
        cout << "~W()" << endl;
    }
};
void f1(W w) {
​
}
int main()
{
    f1(W());   //先构造一个匿名对象,然后作为参数 传值传参过去
    return 0;
}

结果:

依然没调用拷贝构造。

看看程序怎么运行的:

还是刚刚讲的,这是因为编译器的优化,将 构造+拷贝构造 直接优化成了 一步构造。

结论:一个连续的表达式步骤中,连续构造一般都会被优化。

传值返回

可以优化的情况:

class W
{
public:
    //构造函数
    W(int w=0) 
        :_w(w)
    {
        cout << "W()" << endl;
    }
    //拷贝构造函数
    W(const W& w) 
    :_w(w._w)
    {
        cout << "W(const W& w)" << endl;
    }
    //析构函数
    ~W(){
        cout << "~W()" << endl;
    }
private:
    int _w;
};
​
W func() {
    W ret;  //1次构造
    return ret;  //1次拷贝构造:将ret的值通过拷贝构造返回
}
​
int main()
{
    W w1=func();  //W w1=……仍是一次拷贝构造。所以按理说是“1构造+2拷贝构造”
    return 0;
}

然而实际上只进行了“1构造+1拷贝构造”:

为什么拷贝构造从2次变成了1次?

原来,这也是编译器的优化,它会将两个拷贝构造,优化成一个。

这里用图说明一下:

不能优化的情况

上面这种情况和下面的这种要区分,下面这种是不能优化的:

class W
{
public:
    //构造函数
    W(int w=0) 
        :_w(w)
    {
        cout << "W()" << endl;
    }
    //拷贝构造函数
    W(const W& w) 
    :_w(w._w)
    {
        cout << "W(const W& w)" << endl;
    }
    //赋值运算符
    W& operator=(const W& w) {
        cout << "W& operator=(const W& w)" << endl;
        if (this != &w) {
            _w = w._w;
        }
        return *this;
    }
    //析构函数
    ~W(){
        cout << "~W()" << endl;
    }
private:
    int _w;
};
W func() {
    W ret;
    return ret;
}
​
int main()
{
    W w1; 
    w1 = func();  //赋值接收对象
    return 0;
}

这种是分4步进行的:

可见,赋值接收对象 不如 拷贝构造的方式接收。后者可以被优化。

总结

1.连续的 构造和拷贝构造 会被优化成 直接调用构造。(分步的就无法优化了)

2.产生的临时变量往往会被优化掉。

题目的解析

我们现在回过头看看一开始那道题:

首先,W x;是1次构造。

然后,f(x)会把x的值拷贝给u,是1次拷贝构造。

在函数f(W u)里,v的实例化是1次拷贝构造.

w究竟是拷贝构造还是赋值的呢?因为w原先不存在,所以不是赋值,是1次拷贝构造。

return w;(这里最易错) 原本是要拷贝产生临时变量,再用临时变量拷贝构造出y的。但经过编译器的优化,升级成一步拷贝构造。

所以,一共1构造+4拷贝构造。

把这题升级一下:

几次构造?几次拷贝构造?

和上题同理,只不过这次return w将连续的三步优化成一步。

答案:1次构造 7次拷贝构造

  • 12
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 10
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值