【C++进阶笔记】对象优化（1）

最新推荐文章于 2024-06-09 20:18:37 发布
最新推荐文章于 2024-06-09 20:18:37 发布
阅读量157 收藏 2
点赞数 11
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47023748/article/details/134716015
版权

【C++进阶笔记】对象优化（1）

文章目录

1. 类内的函数调用

C++构造对象时可能会调用的函数：构造函数、拷贝构造函数以及赋值重载函数。对象结束作用域时会调用析构函数。

1.1 对象构造时

示例

#include <iostream>
using namespace std;
class Test {
public:
    Test(int a = 5, int b = 5) : m_A(a), m_B(b) {
        cout << "Test(int, int)" << endl;
    }
    ~Test() {
        cout << "~Test()" << endl;
    }
    Test(const Test& other) : m_A(other.m_A), m_B(other.m_B) {
        cout << "Test(&)" << endl;
    }
    void operator=(const Test& other) {
        m_A = other.m_A;
        m_B = other.m_B;
        cout << "operator=" << endl;
    }
    int getData() const {
        return m_A;
    }
private:
    int m_A;
    int m_B;
};
Test t1(10, 10);
int main() {
    Test t2(20, 20);
    Test t3 = t2;
    static Test t4 = Test(20, 20); 
    t2 = Test(20, 20);
    t2 = (Test)(20, 20);
    t2 = 60;
    Test* t5 = new Test(20, 20);
    Test* t6 = new Test[2];
    //Test* t7 = &Test(30, 30);
    const Test& t8 = Test(20,20);
    delete t5;
    delete[] t6; 
    return 0;
}

运行结果

  1. t1是全局变量，最先构造，调用构造函数
  2. t3 = t2 调用的时拷贝构造函数，并不是赋值重载函数，不能简单地认为 ’=‘ 就代表了调用了赋值重载函数。
  3. Test t4 = Test(20, 20) 等价于Test t4(20, 20), 调用构造函数
  4. t2 = Test(20, 20), 调用赋值重载函数，在赋值重载函数前会调用构造函数构造临时对象，完成复制后，临时对象调用析构函数。
  5. t2 = (Test)(20, 20) 和 t2 = 60, 前者属于强转，(20, 20)等价于20，调用构造函数构造临时对象，然后调用赋值函数；后者将一个整形变量赋值给类对象，编译器同样将整形作为参数调用构造函数构造临时对象，然后调用赋值函数。临时对象都会析构。
  6. t5, t6 属于new出来的对象，调用构造函数
  7. t7 为非法赋值（在某些编译器可以编译通过）。Test(30, 30) 先构造临时对象，然后t7作为类指针指向该临时对象，但是临时对象在结束该语句时析构，相对于t7指向了一块被释放的内存（野指针！）。
  8. Test &t8 = Test(20, 20) 类似于上面的t4， 调用构造函数。

1.2 函数（类外的）调用时

讨论类的对象作为参数被调用时所调用的函数。
示例

#include <iostream>
using namespace std;
class Test {
public:
    Test(int a = 5) : m_A(a) {
        cout << "Test(int)" << endl;
    }
    ~Test() {
        cout << "~Test()" << endl;
    }
    Test(const Test& other) : m_A(other.m_A) {
        cout << "Test(&)" << endl;
    }
    void operator=(const Test& other) {
        m_A = other.m_A;
        cout << "operator=" << endl;
    }
    int getData() const {
        return m_A;
    }
private:
    int m_A;
};
Test getObject(Test t) {
    int val = t.getData();
    Test tmp(val);
    cout << "----------------------" << endl;
    return tmp;
}

int main() {
    Test t1;
    Test t2;
    t2 = getObject(t1);
    return 0;
}

在这里插入图片描述
这里我的运行结果也视频中的结果不一样，主要是在函数返回值处，视频中的结果显示调用的拷贝构造来产生局部变量的临时变量。但我的结果中并未调用拷贝构造函数。以下是GPT-4的解释。

GPT-4 : 函数执行到末尾，返回局部对象 tmp。由于返回的是局部对象，通常情况下会调用拷贝构造函数来创建返回值的副本。然而，在C++11及以后的版本中，编译器可能会使用（Named）返回值优化（(N)RVO），以避免不必要的拷贝构造调用。一般的g++编译器都是默认开启此优化的。

此外，需要注意的是t2 = getObject(t1);实参 t1 到形参 t 属于初始化，调用拷贝构造函数构造 t。

2.三条优化准则

2.1 函数参数传递过程中，对象优先按引用传递，不要按值传递

值传递：Test getObject(Test t)
引用传递：Test getObject(Test &t)
使用引用传递优点：调用getObject函数时，从实参到形参不需要调用拷贝构造函数，同样也减少了一次析构函数的调用。引用传递相当于是调用对象的另一个名字，值传递的形参是一个全新的临时变量，需要调用拷贝构造函数去构造。

2.2 函数返回对象时，优先返回一个临时对象，而不要返回定义过的对象

Test tmp(val); return tmp;
上面的两行代码，是通过构造临时对象，并返回临时对象。可将上面两行改写为：
return Test(val);
直接返回一个临时对象，该情况下不会调用任何构造函数或者拷贝构造函数。该return语句的任务是要在main的栈帧上构造一个对象，将此对象赋值给t2。所以我们可以用临时对象拷贝构造一个新对象（1.1中的第3条），这样只会调用一次构造函数，不会产生临时对象后再调用拷贝构造再析构。类似于上面提到的RVO（返回值优化）。

2.3 接收返回值是对象的函数调用时，优先按初始化的方式接收，不要按赋值的方式接收

1.Test t1; Test t2; t2 = getObject(t1);改写为以下的代码：
2.Test t1; Test t2 = getObject(t1;)
代码2同样是用临时对象拷贝构造一个新对象（1.1中的第3条），临时对象会被优化，只会调用构造函数。代码1属于赋值，必须将存在临时对象才能进行赋值。
优化后的结果
通过上面三次优化，最后只调用了两次构造函数和析构函数，效率大大提高。

3. 右值引用、移动语义、完美转发

3.1 CMyString的问题

class CMyString {
public:
    CMyString(const char* str = nullptr) {
        cout << "CMyString(const char*)" << endl;
        if (str != nullptr) {
            mptr = new char[strlen(str) + 1];
            strcpy(mptr, str);
        } else {
            mptr = new char[1];
            *mptr = '\0';
        }
    }
    ~CMyString() {
        cout << "~CMyString" << endl;
        delete[] mptr;
        mptr = nullptr;
    }
    CMyString(const CMyString& str) {
        cout << "CMystring(const CMyString&)" << endl;
        mptr = new char[strlen(str.mptr) + 1];
        strcpy(mptr, str.mptr);
    }
    CMyString& operator=(const CMyString& str) {
        cout << "operator=(const CMyString)" << endl;
        if (this == &str) {
            return *this;
        }
        delete[] mptr;
        mptr = new char[strlen(str.mptr) + 1];
        strcpy(mptr, str.mptr);
        return *this;
    }
    const char* c_str() const {
        return mptr;
    }
private:
    char* mptr;
};

CMyString GetString(CMyString& str) {
    const  char* pstr = str.c_str();
    CMyString tmpstr(pstr);
    return tmpstr;
}
int main() {
    CMyString str1("aaaaaaaaaaaaaaaaaaaa");
    CMyString str2;
    str2 = GetString(str1);
    cout << "----------------" << endl;
    return 0;
}

在这里插入图片描述
问题：str2 = GetString(str1)构造临时变量，赋值给str2，然后析构临时变量。假设mptr指向了一段很长的字符串，那么构造临时变量会造成很大的内存消耗，同时，该临时变量只是赋值给了str2，之后面的语句中没有任何作用便析构掉了，这是一种很大的浪费，因此，我们希望能省去构造临时变量的过程。直接将str1的mptr赋值给str2的mptr。（临时对象是使用后即销毁的资源，所以不希望其去占用外部资源）

3.2 优化

3.2.1 右值引用

左值：有名字，有内存（既可以出现在等号左边又可以在等号右边）。
右值：没有名字（临时量），无内存（只能出现在等号右边），举例：常量、函数返回值等。
int a = 10; // a 属于左值
int &b = a; // 左值引用
int &&c = a; // 错误，左值不能赋值给右值引用
int && d = 20; // 右值引用
int &e = d // 一个右值引用变量，本身是一个左值

// 带左值引用参数的拷贝构造
CMyString(const CMyString& str) {
    cout << "CMystring(const CMyString&)" << endl;
    mptr = new char[strlen(str.mptr) + 1];
    strcpy(mptr, str.mptr);
}
// 带右值引用参数的拷贝构造
CMyString(CMyString&& str) {
    cout << "CMystring(const CMyString&&)" << endl;
    mptr = str.mptr;
    str.mptr = nullptr;
}
// 带左值引用参数的赋值重载函数
CMyString& operator=(const CMyString& str) {
    cout << "operator=(const CMyString&)" << endl;
    if (this == &str) {
        return *this;
    }
    delete[] mptr;
    mptr = new char[strlen(str.mptr) + 1];
    strcpy(mptr, str.mptr);
    return *this;
}
// 带右值引用参数的赋值重载函数
CMyString& operator=(CMyString&& str) {
    cout << "operator=(const CMyString&&)" << endl;
    if (this == &str) {
        return *this;
    }
    delete[] mptr;
    mptr = str.mptr;
    str.mptr = nullptr;
    return *this;
}

在CMyString类中添加带右值引用参数的拷贝构造和带右值引用参数的赋值重载函数，str2 = GetString(str1)，等号右边出现临时变量，编译器优先匹配参数带右值引用的赋值重载函数，可以省去内存的开辟。（相当于深拷贝于浅拷贝的区别）

3.2.2 移动语义

int main() {
    CMyString str1("aaaaaaaaaaaaaaaaaaaa");
    vector<CMyString> vec;
    vec.reserve(10);
    cout << "-----------------" << endl;;
    vec.push_back(move(str1));
    vec.push_back(CMyString("bbb"));
    cout << "-----------------" << endl;
    return 0;
}

#include <utility>
std::move();
move(str1)返回的是一个右值引用，调用移动构造。如果str1在之后都不会再使用，可以使用move调用移动构造，使用浅拷贝，减少内存的开辟。

3.2.3 完美转发

对象再经过函数参数传递时，其类型可能会改变，例如从右值变为左值。

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10);           // 右值
	int a;         
	PerfectForward(a);            // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);      // const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

在这里插入图片描述
上面的代码与图片来自【C++杂货铺】一文总结C++11新特性：右值引用 | 移动语义 | 完美转发

模板中的 && 不代表右值引用，而是万能引用，其既能接受左值，又能接受右值。模板的万能引用只是提供了能够同时接受左值和右值的能力（包括 const 左值和 const 右值）。如上代码：实参如果传递的是一个左值 a，那么模板实例化出来的就是左值引用 int& t，有的书上也管这个叫引用折叠；实参如果传递的是一个右值 10，那么模板实例化出来的就是 int&& t（const 左值和 const 右值也类似）。
————————————————
版权声明：本文为CSDN博主「春人.」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_63115236/article/details/133908793

可以看到结果与我们的预期似乎有出入，常量10以及std::move(a)都是右值，但是最后打印出来的却是左值引用。上面提到过右值引用本身还是一个左值，变量传递到Fun()函数时，都是左值引用，我们希望能够变量的类型进行完美的传递，可以使用完美转发std::forward。

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

template<typename T>
void PerfectForward(T&& t)
{
	Fun(forward<T>(t));//进行完美转发
}
int main()
{
	PerfectForward(10);           // 右值
	int a;
	PerfectForward(a);            // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);      // const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

在这里插入图片描述
上面的代码与图片来自【C++杂货铺】一文总结C++11新特性：右值引用 | 移动语义 | 完美转发

4. 结语

看了施磊的C++进阶课程，重新学了一下右值引用、移动语义和完美转发，也搞懂了之前一些比较模糊的概念。不同的写法，对函数方法的调用也有着巨大的差别，尤其在数值相对较大时，性能差距就会比较明显。

瓜魔
关注
  • 11
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++进阶笔记源码
02-03
C++是一门中级语言，以效率至上所著称，很多朋友觉得C++很难，相信这个由多年C++开发工作者所写的经验笔记对你会很有帮助。
C++进阶STL笔记资料.zip
07-22
C++进阶STL笔记
（C++进阶）boost库笔记
qq_57594025的博客
03-14 468
boost::function 是 Boost 库中提供的一个通用函数对象包装器，它可以存储指向任何可调用对象的指针，并且可以在任何时候通过 operator() 调用。这个功能类似于C++11及以后版本中的 std::function。使用 boost::function 的主要好处是可以创建类型安全的函数指针容器，可以接受不同类型的函数、成员函数、lambda 表达式或仿函数（functor）作为参数，方便在算法和数据结构中传递可调用实体。
C/C++进阶学习笔记
我不是斗哥的博客
08-24 1432
2016.9.13@为什么构造函数不能是虚函数首先，虚函数的执行依赖于虚函数表vtable， 而在虚函数表就是在构造函数中初始化的， 怎么初始化的呢？ 先初始化一个vptr, 再让它指向正确的虚函数表。因此，如果构造函数本身就是虚函数，那么在虚函数表还没初始化的情况下，声明构造函数为虚函数完全是没有意义可言的。2016.9.10@由“MFC类库中，为什么虚析构函数是必要的”引发出的问题201
【C++学习笔记】C++类和对象
qq_41854911的博客
08-04 1210
文章目录C++类的定义和对象的创建详解类的定义创建对象访问类的成员使用对象[指针](http://c.biancheng.net/c/80/)总结C++类的成员变量和成员函数详解在类体中和类体外定义成员函数的区别C++类成员的访问权限以及类的封装简单地谈类的封装对private和public的更多说明C++对象的内存模型C++函数编译原理和成员函数的实现C++函数的编译成员函数的调用C++构造函数详解构造函数的重载默认构造函数C++构造函数初始化列表初始化 const 成员变量C++析构函数详解析构函数的执
C++进阶之高质量代码编程
suren_jun的博客
08-14 1020
在之前已经讲过C++的基础，其实许多编程语言的入门大差不差，无外乎数据类型，数据结构，循环语句，条件语句，其实真正区别的是用途，已经语言的特性，这个才是最为重要的，不过在这之前，一个良好的代码风格是必不可少的，所以这里介绍一篇自己总结的《C++高质量代码》的笔记。......
【C++进阶之路】list的基本使用和模拟实现
Shun_Hua的博客
07-19 1043
主要讲解list的基本使用和模拟实现。
C++ 学习路线：快速入门到进阶
于小咸的博客
04-10 5080
C/C++ 是一门底层、细粒度、功能强大、学习曲线陡峭的语言，掌握这门语言的程序员通常有着更长的生命周期以及更深的护城河。但入门门槛高也是不争的事实，这篇文章把C++学习划分为入门、进阶、深入三个阶段，每步提供相应的学习方法和资源，帮助大家更好地掌握这门语言。
C++ QT进阶
杰之行的博客
07-03 5721
前言 为什么会有这篇文章呢？为什么学QT呢？ 学了c/c++，除了会刷几道leetcode，用二分法解个方程，尝试深搜走地图，用线性筛找个素数······；难道C++的应用就是为了ACM吗？不，个人觉得并不是，这不是自己的初衷！于是乎，开始学习数据结构，网络编程，系统编程，web前端(html、css、JavaScript)······ 因为学了c++还没找到一个好的应用，感觉很糟！如果您想了解为什么学习qt,请点击链接查看：《为什么 qt 成为 c++ 界面编程的第一选择？》 推荐一个详细
Redis 进阶笔记
杜莱的博客
07-29 1367
第一部分 Redis 快速实战 第一节 缓存原理与设计 1.1 缓存基本思想 1.11 缓存的使用场景 DB 缓存，减轻 DB 服务器压力 一般情况下数据存在数据库中，应用程序直接操作数据库。 当访问量上万，数据库压力增大，可以采取的方案有： 读写分离，分库分表 当访问量达到 10 万、百万，需要引入缓存。 将已经访问过的内容或数据存储起来，当再次访问时先找缓存，缓存命中返回数据。 不命中再找数据库，并回填缓存。 提高系统响应 数据库的数据是存在文件里，也就是硬盘，与内存做交换（swap） 在大量瞬间访问
c++笔记2
weixin_70468627的博客
02-01 1306
栈 stack的基本操作 在C++的标准库中， 有封装好的栈stack，stack是一个模板类，定义stack的示例代码如下： stack<类型> 对象： stack<int> s; 一种常见的数据结构，遵循后进先出，先进后出的原则。有一个连续的内存区域组成，栈顶（top） 线性表允许插入和删除的那一段。值得注意的是，栈顶指针top的指向是有些两种方式的，一种是指向栈顶当前元素，一种是指向栈顶的下一位置。两种指向方式对栈的操作影响不大，只是在判断栈顶位置的时候略
C++进阶STL源码笔记
11-15
C++课堂源码与笔记，需要的朋友请自行下载，如果有C++编程基础的朋友，可以配合视频教程，参考学习。
C++进阶STL适配器总结1
08-08
}3. 插入迭代器适配器|函数|作用||:-||insert_iterator<Container> inserter (Container& x, Itera
C++基础和进阶笔记 .docx
08-02
二、类和对象 23 三、继承和派生 45 四、多态 53 五、纯虚函数和抽象类 67 六、函数模板和类模板 80 七、C++的类型转换 102 八、异常处理机制专题 106 九、C++输入和输出流 121 十、STL实用技术专题 144
【C++】——Stack与Queue（含优先队列（详细解读）
最新发布
m0_74092462的博客
06-09 967
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 128
BCSP-X 11题 C++代码详解
【C语言从入门到入土】第六章 指针(下)
v13111329954的博客
06-08 665
本文主要介绍了指针偏移，通过指针引用数组，指针数组，数组指针，函数指针，指针函数，二级指针
LeetCode 算法：轮转数组c++
小金牛来了
06-09 643
LeetCode 算法：轮转数组c++
c++ 进阶学习pdf
02-05
1. 深入了解PDF格式的特点和原理。PDF是一种便携式文档格式，可以跨平台、跨设备进行阅读和编辑。学习PDF的技术细节，了解其内部结构和编码方式，有助于更好地理解和应用PDF。 2. 学习PDF编辑和制作工具的高级功能...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值