C++中拷贝对象时编译器做出的一些优化

最新推荐文章于 2024-05-11 18:41:21 发布
最新推荐文章于 2024-05-11 18:41:21 发布
阅读量1.1k 收藏 19
点赞数 20
分类专栏： C++基础知识 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73281594/article/details/136993630
版权

目录

拷贝对象时编译器做出的一些优化

参数传递优化

返回值优化

拷贝对象时编译器做出的一些优化

📌

下面的优化结果由编译器决定，不同的编译器优化结果可能不同，视具体情况而定

参数传递优化

  1. 在前面的explicit关键字部分提到过编译器会对在单行的构造+拷贝构造优化为构造
#include <iostream>
using namespace std;

class test
{
private:
    int _num;
public:
    test(int num)
        :_num(num)
    {}

    void print()
    {
        cout << _num << endl;
    }
};

int main()
{
    test t = 1;
    t.print();
    return 0;
}
输出结果：
1
  1. 在给函数形参传递实参时，如果直接传递已经创建的对象时，编译器不会对其进行优化
#include <iostream>
using namespace std;

class test
{
private:
    int _num;
public:
    test(int num)
        :_num(num)
    {
        cout << "构造函数" << endl;
    }

    void print()
    {
        cout << _num << endl;
    }

    test(const test& t)
    {
        _num = t._num;
        cout << "拷贝构造函数" << endl;
    }

    ~test()
    {
        cout << "析构函数" << endl;
    }
};

void func1(const test t)
{
    cout << "func1" << endl;
}

int main()
{
    test t1(1);
    func1(t1);
    return 0;
}
输出结果：
构造函数
拷贝构造函数
func1
析构函数
析构函数

在上面的代码中，首先test类创建了一个对象为t1，此时调用构造函数，当t1作为函数实参传递给func1函数，此时会调用拷贝构造函数将t1对象拷贝给形参t，接着进入func1函数栈帧空间执行func1函数体的语句，当func1函数结束执行后调用析构函数销毁形式参数对象t，最后调用析构函数销毁局部对象t1

对上面的代码进行改进，直接传递整型1给func1函数，如下面代码

#include <iostream>
using namespace std;

class test
{
private:
    int _num;
public:
    test(int num)
        :_num(num)
    {
        cout << "构造函数" << endl;
    }

    void print()
    {
        cout << _num << endl;
    }

    test(const test& t)
    {
        _num = t._num;
        cout << "拷贝构造函数" << endl;
    }

    ~test()
    {
        cout << "析构函数" << endl;
    }
};

void func1(const test t)
{
    cout << "func1" << endl;
}

int main()
{
    func1(1);
    return 0;
}
输出结果：
构造函数
func1
析构函数

在上面的代码中，直接将1作为对象传递给自定义类型的形参t时，常规的步骤为：调用构造函数用整型1初始化一个临时对象，再调用拷贝构造函数将临时对象中的内容拷贝给形参对象，但是此处编译器会对其进行优化为直接调用构造函数，用整型1初始化形参对象t

同理，使用匿名对象作为实际参数传递给自定义类型的形参时，编译器也会有所优化

#include <iostream>
using namespace std;

class test
{
private:
    int _num;
public:
    test(int num)
        :_num(num)
    {
        cout << "构造函数" << endl;
    }

    void print()
    {
        cout << _num << endl;
    }

    test(const test& t)
    {
        _num = t._num;
        cout << "拷贝构造函数" << endl;
    }

    ~test()
    {
        cout << "析构函数" << endl;
    }
};

void func1(const test t)
{
    cout << "func1" << endl;
}

int main()
{
    func1(test(2));

    return 0;
}
输出结果：
构造函数
func1
析构函数

在上面的代码中，使用整型2创建了一个匿名对象，常规步骤为：调用构造函数使用整型2创建匿名对象，接着调用拷贝构造函数将匿名对象中的内容拷贝给形式参数，但是编译器优化为直接使用整型2为形式参数初始化

但是如果函数的形式参数为引用时，则不会有任何优化，直接调用构造函数进行初始化对象再由自定义类型的引用形参接收实参对象的地址

📌

注意：使用引用传参时一定要在形式参数处加const修饰

#include <iostream>
using namespace std;

class test
{
private:
    int _num;
public:
    test(int num)
        :_num(num)
    {
        cout << "构造函数" << endl;
    }

    void print()
    {
        cout << _num << endl;
    }

    test(const test& t)
    {
        _num = t._num;
        cout << "拷贝构造函数" << endl;
    }

    ~test()
    {
        cout << "析构函数" << endl;
    }
};

void func1(const test& t)
{
    cout << "func1" << endl;
}

int main()
{
    test t1(1);
    func1(t1);
    cout << endl;
    func1(1);
    cout << endl;
    func1(test(1));

    return 0;
}
输出结果：
构造函数
func1

构造函数
func1
析构函数

构造函数
func1
析构函数
析构函数

返回值优化

#include <iostream>
using namespace std;

class test
{
private:
    int _num;
public:
    test(int num)
        :_num(num)
    {
        cout << "构造函数" << endl;
    }

    void print()
    {
        cout << _num << endl;
    }

    test(const test& t)
    {
        _num = t._num;
        cout << "拷贝构造函数" << endl;
    }

    test& operator=(const test& t)
    {
        cout << "赋值运算符重载函数" << endl;
        if (this != &t)
        {
            _num = t._num;
        }
        return *this;
    }

    ~test()
    {
        cout << "析构函数" << endl;
    }
};

test func()
{
    cout << "func" << endl;
    test t(1);
    return t;
}

int main()
{
    func();

    return 0;
}
  1. 当调用的函数有返回对象时，使用该对象初始化对象
#include <iostream>
using namespace std;

class test
{
private:
    int _num;
public:
    test(int num)
        :_num(num)
    {
        cout << "构造函数" << endl;
    }

    void print()
    {
        cout << _num << endl;
    }

    test(const test& t)
    {
        _num = t._num;
        cout << "拷贝构造函数" << endl;
    }

    test& operator=(const test& t)
    {
        cout << "赋值运算符重载函数" << endl;
        if (this != &t)
        {
            _num = t._num;
        }
        return *this;
    }

    ~test()
    {
        cout << "析构函数" << endl;
    }
};

test func()
{
    cout << "func" << endl;
    test t(1);
    return t;
}

int main()
{
    test t1 = func();

    return 0;
}

在上面的代码中，使用func函数的返回值初始化t1对象，常规的过程为：调用拷贝构造函数将func函数的返回值放入一个自定义类型的临时变量中，再通过拷贝构造函数将临时变量中的内容拷贝给t1对象，但是这里编译器会优化为调用一个构造函数将func的返回值作为初始化值直接初始化t1对象

但是如果将两个步骤分开，如下面的代码

#include <iostream>
using namespace std;

class test
{
private:
    int _num;
public:
    test()
        :_num()
    {
        cout << "构造函数" << endl;
    }

    void print()
    {
        cout << _num << endl;
    }

    test(const test& t)
    {
        _num = t._num;
        cout << "拷贝构造函数" << endl;
    }

    test& operator=(const test& t)
    {
        cout << "赋值运算符重载函数" << endl;
        if (this != &t)
        {
            _num = t._num;
        }
        return *this;
    }

    ~test()
    {
        cout << "析构函数" << endl;
    }
};

test func()
{
    cout << "func" << endl;
    test t;
    return t;
}

int main()
{
    test t1;
    t1 = func();
    return 0;
}

在上面的代码中，因为t1对象需要完成实例化，所以会调用构造函数，接着执行t1 = func()语句，因为赋值运算符有从右往左的结合性，所以先执行func函数，在func函数中会再次调用构造函数创建一个对象，（注意中间有一个过程为：调用拷贝构造将返回对象拷贝到临时对象中，再调用析构函数销毁局部对象t）此时执行赋值语句，此时调用赋值运算符重载函数，将t对象的内容给t1对象

  1. 当返回的是匿名对象，使用该匿名对象初始化对象
#include <iostream>
using namespace std;

class test
{
private:
    int _num;
public:
    test()
        :_num()
    {
        cout << "构造函数" << endl;
    }

    void print()
    {
        cout << _num << endl;
    }

    test(const test& t)
    {
        _num = t._num;
        cout << "拷贝构造函数" << endl;
    }

    test& operator=(const test& t)
    {
        cout << "赋值运算符重载函数" << endl;
        if (this != &t)
        {
            _num = t._num;
        }
        return *this;
    }

    ~test()
    {
        cout << "析构函数" << endl;
    }
};

test func()
{
    cout << "func" << endl;
    return test();
}

int main()
{
    test t1 = func();
    return 0;
}
输出结果：
func
构造函数
析构函数

在上面的代码中，先执行func函数，常规步骤为：执行test类中的构造函数创建一个匿名对象，接着调用拷贝构造将匿名对象拷贝到临时对象中返回，接着调用拷贝构造将返回值拷贝给t1对象，但是此处编译器会优化为直接用返回的匿名对象的内容作为初始值初始化对象t1

总结：

  1. 为了编译器更好得优化，在传参数时，可以考虑使用引用变量作为参数
  2. 当使用到返回值时，如果能用引用就使用引用，不能使用引用需要返回值时，可以考虑返回匿名对象

怡晗★
关注
  • 20
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++中拷贝构造函数的应用
01-20
C++中拷贝构造函数的定义 　有一个参数的类型是其类类型的构造函数是为拷贝构造函数。如下： 　X::X( const X& x); 　Y::Y( const Y& y， int =0 ); 　//可以是多参数形式，但其第二个即后继参数都有一个默认值 ...
C++中拷贝构造函数的应用详解
12-31
一、C++中拷贝构造函数的定义： 有一个参数的类型是其类类型的构造函数是为拷贝构造函数。 如下所示： X::X( const X& x); Y::Y( const Y& y, int =0 );...三、C++中编译器何时合成拷贝构造函数 并不是
C++ | 探究拷贝对象时的一些编译器优化
做技术人 · 产优质博客 · 找好工作
04-16 1020
揭晓一下拷贝构造过程中你所不知道的一些编译器优化工作🔧
C++中拷贝对象时的一些编译器优化和建议
2401_84568462的博客
04-23 1278
在传参和传返回值的过程中，一般编译器会做一些优化，以此来减少对象的拷贝，这个在一些场景下还是比较有用的，这种优化可以在一定程度上提高程序运行的效率。
C++基础——匿名对象介绍、拷贝对象时的一些编译器优化
weixin_69283129的博客
11-12 961
C++匿名对象，编译器对于拷贝对象做出的优化
C++编译器优化问题
qq_62745420的博客
07-18 1087
首先使用a拷贝构造了形参aa，然后aa拷贝构造了copy1，copy1拷贝构造了copy2（注意这里虽然是等号也是拷贝构造，因为这里的copy2还是对象创建初始化阶段，只有对象创建出来之后再给对象赋值才是赋值）copy2拷贝构造了一个临时对象然后传参给test，使用这个临时对象1拷贝构造了aa然后aa重复上面再函数中的拷贝构造，返回值，因为是值返回所以先再main函数的栈帧内开辟一个临时对象2，调用了一次拷贝构造，然后再用哦这个临时对象2，拷贝构造了ret对象。所以编译器进行了优化，那么优化的地方在哪呢？.
C++性能优化笔记-7-编译器中的优化-1-编译器如何优化代码
工作学习记录
09-10 1288
编译器中的优化编译器如何优化函数内联常量折叠和常量传播指针消除公共子表达式消除寄存器变量生命周期分析合并相同的分支消除跳转循环展开循环不变代码移动归纳变量调度代数化简去虚拟化 编译器如何优化 现代编译器能够对代码做很多修改，以提高性能。了解编译器可以做什么，不可以做什么，对开发者来说是有用的。下边的小节描述了开发者需要了解的一些编译器优化的内容。 函数内联 编译器可以用被调用函数体来替换原来的函数调用。例子： // Example 8.1a float square (float a) { re
C++对象拷贝
qq_52572621的博客
11-18 2646
首先看下面这张图：假设我们现在有一个对象数组，里边有三个对象，O1、O2和O3；但是随着业务逻辑的提升，这三个对象已经无法满足我们的使用了；那么我们肯定要再添加几个对象进去，但是我们又不想重新创建O1、O2、O3；那么怎么办呢？首先在C语言中，我们肯定是用一些拷贝函数之类的，通过赋值拷贝将一个对象的内容拷贝给另一个对象进行使用；这个过程就叫对象拷贝；当然C++中也有类似拷贝对象内容的方式，并且C++的编译器支持我们用更简单的方式进行内存复制，接下来就让我们看看C++中如何实现对象拷贝；
C++中拷贝构造和赋值重载的注意事项、编译器对构造+拷贝构造或拷贝构造+拷贝构造的优化处理以及匿名类
干脆面la的博客
03-10 656
本文可以帮助你对下面： （1）何时调用拷贝构造何时调用赋值重载（2）在拷贝构造函数和赋值重载函数的参数加const的意义（3）自定义类型的隐式类型转换（4）编译器对自定义类型隐式类型转换的优化（5）自定义类型引用常量的意义（6）匿名类的作用和优化 方面有更加深刻的理解像
[C++] C++编译器 关于构造函数的优化
七月.cc的博客
10-24 728
一些编译器, 对 连续使用的构造函数 会存在优化情况
C++ 函数返回对象时并没有调用拷贝构造函数
nbu_dahe的博客
07-27 4684
C++函数返回的临时对象用来初始化类对象是否调用拷贝构造函数 正常情况下，如果一个函数返回一个类对象，那它会生成一个临时对象进行拷贝。 最近，被这个问题纠结了很久，为什么纠结，因为遇到的代码输出和我预想的并不一样，一度以为并没有临时对象这个东西。 还好终于搞明白了临时对象初始化类对象调用拷贝构造函数的问题！下面是我解疑过程中遇到的代码： #include <iostream> using namespace std; class Test { public: int a; Test(
C++中拷贝构造函数的总结详解
01-20
百度百科上是这样说的：拷贝构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其唯一的参数（对象的引用）是不可变的（const类型）。此函数经常用在函数调用时用户...
从汇编看c++中的默认拷贝函数
12-22
《c++编程思想》上说一个类如果没有拷贝函数，那么编译器会自动创建一个默认的拷贝函数。下面让我们看一下真实的情况。 　首先看一个简单的类X，这个类没有显示定义拷贝构造函数。c++源码如下： class X { ...
C++ 中类的拷贝、赋值、销毁的实例详解
12-25
C++ 中类的拷贝、赋值、销毁的实例详解 本篇文章我们一共讲解一下几个知识点： 类的拷贝构造函数。 类的拷贝赋值运算符。 类的析构。 好了one by one 如果我们没有定义类的拷贝构造函数的话，那么编译器会为我们...
c++父类指针指向子类
最新发布
qq_43700779的博客
05-11 116
父类指针指向子类，调用的函数是谁的
c++ 点到多边形的距离
jacke121的专栏
05-08 289
c++ 点到多边形的距离
初识C语言——第十四天
硬件菜鸟的成长之路
05-07 693
【代码】初识C语言——第十四天。
UE5C++ FString做为参数取值时报错error：C4840
YanisWu的博客
05-11 94
UE5 C++ 的FString类型取值问题。
c++中拷贝构造函数
09-02
在C++中，拷贝构造函数是一种特殊的构造函数，它由编译器在特定情况下自动调用，用于创建一个新的对象并将其初始化为已有对象的副本。拷贝构造函数的参数通常采用引用的方式传递，以避免无限递归的问题。 对于类C中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怡晗★

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值