CppBoost（对象优化）

已于 2024-09-05 19:34:45 修改
阅读量1.3k 收藏 36
点赞数 42
文章标签： c++
于 2024-09-02 23:13:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skyland11/article/details/141827366
版权

在这里插入图片描述

对象使用背后调用的方法

#include<iostream>

using namespace std;

class Test
{
    public:
        Test(int a = 10):ma(a)  {cout<<"Test(int)"<<endl;}
        ~Test(){cout<<"~Test()"<<endl;}
        Test(const Test& t):ma(t.ma) {cout<<"Test(const Test& t)"<<endl;}
        Test& operator=(const Test& t) 
        {
            cout<<"operator="<<endl; 
            ma = t.ma;
            return *this;
        }

    private:
        int ma;
};

int main()
{
    Test t1;	//构造	
    Test t2(t1);    //拷贝构造
    Test t3 = t1;	//拷贝构造

    //Test(20) 显式生成临时对象 生存周期：所在的语句 
    Test t4 = Test(20);
    /*  调用过程？ 先调用构造生成临时对象，再调用拷贝构造，析构？ */

    return 0;
}

输出结果：
在这里插入图片描述

从输出结果我们可以看到，C++编译器对于对象构造做出的优化：用临时对象生成新对象的时候，临时对象就不产生了，直接构造新对象就可以了，即 Test t4 = Test(20) 等价于 Test t4(20)

int main()
{
    Test t1;
    Test t2(t1);    
    Test t3 = t1;

    //Test(20)  
    Test t4 = Test(20);

    t4 = t1;	//拷贝构造
    t4 = Test(30);		

    return 0;
}

在这里插入图片描述
用临时对象给已有对象赋值会先创建临时对象，再调用赋值运算符重载

显式 or 隐式 生成临时对象：

int main()
{
    Test t4;
	//显式生成临时对象
    t4 = Test(30);
    t4 = (Test)30; 
	//隐式生成临时对象
    t4 = 30; 

    return 0;
}

在这里插入图片描述

指针 引用 赋值临时对象：

int main()
{
    Test *p = &Test(30);

    const Test &ref = Test(40);

    return 0;
}

在这里插入图片描述
无法对临时对象取地址，临时对象的生命周期只在所在语句，出语句临时对象就会被析构

在这里插入图片描述
引用是变量的别名，可以用临时对象赋值给常对象

示例：

#include<iostream>

using namespace std;

class Test
{
    public:
        Test(int a = 5,int b = 5): ma(a), mb(b) 
        {
            cout << "Test(int,int)" << endl;
        }
        ~Test()
        {
            cout << "~Test()" << endl;
        }
        Test(const Test &src): ma(src.ma), mb(src.mb)
        {
            cout << "Test(const Test &)" << endl;
        }
        void operator=(const Test &src)
        {
            ma = src.ma;
            mb = src.mb;
            cout << "operator=" << endl;
        }

    private:
        int ma;
        int mb;
};

Test t1(10, 20);    // 1.Test(int,int)
int main()
{
    Test t2(20,20);     // 3.Test(int,int)
    Test t3 = t2;       // 4.Test(const Test &)
    static Test t4 = Test(30, 40);      // 5.Test(int,int)
    t2 = Test(40, 50);      // 6.Test(int,int)    operator=  ~Test()
    t2 = (Test)(50, 60);       // 7.Test(int,int)   operator=     ~Test()
    t2 = 60;               // 8.Test(int,int)    operator=     ~Test()
    Test *p1 = new Test(70, 80);    // 9.Test(int,int)
    Test *p2 = new Test[2];                 // 10.Test(int,int)  Test(int,int)
    const Test &p3 = Test(90, 100);             // 11.Test(int,int)
    delete p1;              // 12.~Test()   free(p1)
    delete[] p2;            // 13.~Test()   ~Test()    free(p2)
}
Test t5(100,100);   // 2.Test(int,int)

运行一下~

在这里插入图片描述

函数调用过程中对象背后调用的方法

参考以下示例代码，分析其函数调用过程

#include<iostream>

using namespace std;

class Test
{
public:
    Test(int a = 10):a_(a)  
    {
        cout << "Test()" << endl; 
    }
    ~Test()     
    {
        cout << "~Test()" << endl;
    }
    Test(const Test& t):a_(t.a_)
    {
        cout << "Test(const Test& t)" << endl;
    }
    void operator=(const Test& t)
    {
        cout << "operator=(const Test& t)" << endl;
        a_ = t.a_;
    }
    int getA() const { return a_; }

private:
    int a_;
};

Test GetObj(Test t)
{
    int val = t.getA();
    Test tmp(val);
    return tmp;
}

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

在这里插入图片描述
首先main函数里的 t1、t2 调用构造函数，GetObj(t1) 调用 t1 给 GetObj函数初始化形参Test t，接下来tmp调用构造函数，return tmp 构造了一个临时对象，GetObj函数结束，进行局部对象析构，先对tmp进行析构，然后对形参 t 进行析构；赋值运算符重载，使用临时对象对 t2 赋值，接着临时对象析构，t2、t1析构

三条对象优化的规则

- 函数参数传递过程中，对象优先按引用传递，不要按值传递
- 函数返回对象的时候，应该优先返回一个临时对象，而不要返回一个定义过的对象
- 接收返回值是对象的函数调用的时候，优先按初始化的方式接收，不要按赋值的方式接收

下面通过代码示例的方式，分析逐条规则的含义：
函数参数传递过程中，对象优先按引用传递，不要按值传递

Test GetObj(Test &t)
{
    int val = t.getA();
    Test tmp(val);
    return tmp;
}

int main()
{
    Test t1;
    Test t2; 
    t2 = GetObj(t1);

    return 0;
}

在这里插入图片描述

Test GetObj(Test &t)
{
    int val = t.getA();
    Test tmp(val);
    return tmp;
}

int main()
{
    Test t1;
    Test t2; 
    t2 = GetObj(t1);

    return 0;
}

在这里插入图片描述
第一段代码 Test 函数形参采用的是对象的值传递，第二段采用的是引用传递，从输出结果来看，采用引用传递的方式输出少了 一段拷贝赋值运算符重载；这是由于采用值传递会先拷贝一份传入参数的数据，用于构建 Test 中的临时对象，如果采用引用传递，可以避免此操作的开销

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

Test GetObj(Test &t)
{
    int val = t.getA();
    Test tmp(val);
    return tmp;
}

int main()
{
    Test t1;
    Test t2; 
    t2 = GetObj(t1);

    return 0;
}

Test GetObj(Test &t)
{
    int val = t.getA();
    return Test(val);
}

int main()
{
    Test t1;
    Test t2; 
    t2 = GetObj(t1);

    return 0;
}

在这里插入图片描述

在这里插入图片描述
在 Test 函数编写过程中，先定义临时对象在返回会先调用构造函数，再调用析构；而将临时对象放在 return 中定义，编译器会用构造的临时对象去拷贝构造新对象，会直接构造新对象，优化了临时对象产生的问题

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

Test GetObj(Test &t)
{
    int val = t.getA();
    return Test(val);
}

int main()
{
    Test t1;
    Test t2; 
    t2 = GetObj(t1);

    return 0;
}

Test GetObj(Test &t)
{
    int val = t.getA();
    return Test(val);
}

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

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

对比分析可以看到编译器以同样地方式进一步作出优化，临时对象不生成了，直接调用两次构造、析构后返回

CMyString代码问题

#include<iostream>
#include<cstring>

using namespace std;

class CMyString
{
public:
    CMyString(); 
    
    CMyString(const char* str)
    {
        cout << "CMyString(const char* str)" << 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& str)" << endl;
        mptr = new char[strlen(str.mptr) + 1];
        strcpy(mptr, str.mptr);
    }
    CMyString& operator=(const CMyString& str)
    {
        cout << "operator=" << 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 GetMyString(CMyString &str)
{
    const char* temp = str.c_str();
    CMyString tempStr(temp);
    return tempStr;
}

int main()
{
    CMyString str("hello");
    CMyString str2;
    str2 = GetMyString(str);
    cout << str2.c_str() << endl;
    
    return 0;
}

在这里插入图片描述
当GetMyString函数中调用构造函数生成临时对象tempStr时，会开辟一块堆上内存复制 str 中 mptr 的内容，因为GetMyString函数结束，临时对象要析构，函数栈帧回退，故 tempStr 临时对象无法返回，此时返回的方式是通过调用拷贝构造，在main函数栈帧上开辟新的内存，创建对象来返回；然后main函数中 str2 调用赋值运算符重载复制GetMyString函数返回的内容（会开辟内存），参考上图，这样就会导致内存频繁开辟释放，如果对象复杂就会造成极大的资源浪费！！！

添加带右值引用参数的拷贝构造和赋值函数

int main()
{
	//左值：有内存、有名字	右值：没名字（临时量）、没内存
	int a = 10;		//定义一个左值
	int &b = a;		//左值引用
	//int &&c = a;	//无法将右值引用绑定到左值
	//int &c = 10;	//无法将左值引用绑定到右值
	/* 
	int tmp = 10;
	const int &c = tmp;
	*/
	const int &c = 10;
	/*
	int tmp = 20;
	const int &&d = tmp;
	*/
	int &&d = 20;	//右值引用
	CMyString &&e = CMyString("aaa");	//右值引用 临时对象
	
	//int &&f = d;	//无法用右值引用 引用一个右值引用变量
	int &f = d;		//一个右值引用变量，本身是一个左值

	return 0;
}

CString添加带右值引用参数的拷贝构造和赋值运算符重载函数

//带左值引用参数的拷贝构造
CMyString(const CMyString &str)
{
	cout << "CMyString(const CMyString&)" <<endl;
	mptr = new char[strlen(str.mptr) + 1];
    strcpy(mptr, str.mptr);
}
//带右值引用参数的拷贝构造
CMyString(CMyString &&str)	//str引用的是一个临时对象
{
	cout << "CMyString(CMyString&&)" <<endl;
	mptr = str.mptr;
	str.mptr = nullptr;
}
//带左值引用的赋值运算符重载函数
CMyString& operator=(const CMyString& str)
{
	cout << "operator=(const CMyString& str)" << 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=(CMyString&& str)" << endl;
    if (this == &str)
    {
        return *this;
    }
    delete[] mptr;
    
    mtpr = str.mptr;
    str.mptr = nullptr;
    return *this;
}

更改临时对象的mptr指针
在这里插入图片描述
operator+函数实现过程

CMyString operator+(const CMyString& str1, const CMyString& str2)
{
    char *ptmp = new char[strlen(str1.mptr) + strlen(str2.mptr) + 1];
    strcpy(ptmp, str1.mptr);
    strcat(ptmp, str2.mptr);
    CMyString tmpStr(ptmp);
    delete []ptmp;
    return tmpStr;	//CMyString& operator=(CMyString&& str)
}

int main()
{
    CMyString str1 = "hello";
    CMyString str2 = "world";
    CMyString str3 = str1 + str2;
    cout << str3 << endl;
    
    return 0;
}

这段代码实现了对于 “+” 的赋值运算符重载，首先开辟一块内存，之后调用构造函数，释放开辟的内存，最后返回对象；同样，这样的操作在赋值运算 “+” 的过程中，开辟新的内存用于临时存储指针内容，又马上释放，增加了开销，造成内存浪费，为了避免此问题，作出如下优化：

CMyString operator+(const CMyString& str1, const CMyString& str2)
{
    CMyString temp;
    temp.mptr = new char[strlen(str1.mptr) + strlen(str2.mptr) + 1];
    strcpy(temp.mptr, str1.mptr);
    strcat(temp.mptr, str2.mptr);
    return temp;		
}

int main()
{
    CMyString str1 = "hello";
    CMyString str2 = "world";
    CMyString str3 = str1 + str2;
    cout << str3 << endl;
    
    return 0;
}

在这里插入图片描述

Eyelar
关注
cppBoost01
m0_57069477的博客
08-14 445
面向对象的基本概念、类与类之间的关系、面向对象的设计原则、设计模式；C++11的线程库、互斥锁、条件变量、pc、线程池；计算机网络的概念、socket网络编程、IO多路复用；Reactor、Reactor + 线程池。
CppBoost（智能指针）
skyland11的博客
09-05 473
从示例代码我们可以看出，构造了一个智能指针类将裸指针包装成私有成员变量使用，并定义了成员方法对裸指针进行解引用操作，main函数中定义了一个智能指针，然后进行解引用操作，当main函数结束，系统会自动调用智能指针中类的析构方法进行堆内存释放，这样就做到了稳定释放内存的效果，其原理是利用了。智能指针其实就是对裸指针的一种封装，那么智能指针是如何做到自动释放内存的呢？那我们在使用指针的过程中如何做到无论我们程序发生异常亦或其他情况都能够稳定的释放内存呢？这个特征，来代替 堆上内存的手动释放。
【无标题】cppBoost网络编程
m0_57069477的博客
08-25 676
当监听的文件描述符个数比较稀疏的时候（比如3， 600， 1023），循环判断比较麻烦，所以需要自定义数据结构：数组。中，这样调用epoll_weit获取就绪文件描述符的时候，只要取队列中的元素即可，操作的时间复杂度恒为O(1)。文件描述符上限（1024），同时监听的文件描述符1024个，历史原因，不好修改，除非重新编译Linux内核。//将对应的文件描述符放在红黑树上进行监听或者将对应的文件描述符从红黑树上删除。，迅速激活这个文件描述符，这样随着文件描述符数量的增加，也不会影响判定就绪的性能。
cppBoost09网络IO编程(二)
m0_57069477的博客
08-25 1494
对于每一个accept执行结束后，说明连接已经建立，所以需要有一个对应的连接对象，也就是 TcpConnection，但是每个对象会关联一个文件描述符connfd，所以有一个记录文件描述符到 TcpConnection的数据结构，可以使用键值对进行存储，这样以后就可以通过文件描述符就可以找 到对应的连接，同时文件描述符是不重复的，所以这里可以选择的数据结构有map或者 unordered_map，我们这里选择map，即。SocketIO类：该类的作用就是封装所有的读写操作，也就是将读写的细节封装到该类中。
cppBoost06~09网络IO编程（一）
m0_57069477的博客
08-25 1581
在父进程中要关闭创建连接的套接字，等待下一个客户端请求连接，所以可以并发式服务器处理多个客户端的请求，一个客户端一个进程；子进程在处理客户端的请求，子进程是长连接的，不断的处理请求，即使子进程中解包，计算，打包的过程时间过长，也不会影响父进程去连接其他客户端的请求。当使用默认的阻塞套接字时（例如上面提到的 1 个线程捆绑处理 1 个连接），往往是把这两个阶段合而为一，这样操作套接字的代码所在的线程就得睡眠来等待消息准备好，这导致了高并发下线程会频繁的睡眠、唤醒，从而影响了 CPU 的使用效率。
CPP项目：Boost搜索引擎
weixin_66828150的博客
02-07 3016
函数来说，我们有两种方法实现它，可以直接调用jieba分词工具直接使用，生成关键字分词，这样做的情况下可能会生成较多的暂停词，搜索结果可能又不太准确的情况，所以我们可以去掉暂停词，这样可以减小关键词的数量，减小查找次数，二区掉暂停词依然需要调用Jieba分词库当中的函数。由于我们使用的是cppjieba分词工具，所以我们需要在使用的时建立分词路径，防止出现错误，在建立cppjieba类的时候，我们也是创建的单例模式，只需要建立一个对象即可，不需要创建多个对象，这和建立索引时候的功能是一样的。
Boost C++库介绍
渡辺麻友
02-21 1190
今天Mayuyu将来讲述一个非常实用的C++库，它叫做Boost C++库。Boost库中加入了一些在实战中非常常用的函数对C++标准进行了扩充，在实际开发中非常有用。   Boost C++的安装包可以在这里下载：http://www.boost.org/   解压后进入目录执行：sh bootstrap.sh。 完成后得到了b2可执行文件，继续执行./b2，最后执行./bjam完成安
在Windows上安装 boost 和 GCC (MinGW)
m0_47696151的博客
11-25 3271
安装 Mingw 下载并安装 Mingw-w64。 安装过程中选择 Architecture select x86_64，其余默认。 添加 Mingw-w64 的 bin 目录至 环境变量 PATH 中。 如果采用默认路径的话，路径地址为 C:\Program Files\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin。 检测安装是否成功g++ --version 如果成功安装，则会输出相应的版本信息。 安装boost 下载并解压出 bo
【C++多线程编程】Boost线程库
热门推荐
华秋实的专栏
05-26 1万+
Boost线程库 Bill Kempf 译：伐木工 标准C++线程即将到来。CUJ预言它将衍生自Boost线程库，现在就由Bill带领我们探索一下Boost线程库。 就在几年前，用多线程执行程序还是一件非比寻常的事。然而今天互联网应用服务程序普遍使用多线程来提高与多客户链接时的效率；为了达到最大的吞吐量，事务服务器在单独的线程上运行服务程序；GUI应用程序将那些费时
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 48
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
STL set
hls0611的博客
11-09 91
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
C 学习（4）
search7的博客
11-05 764
C语言学习，每个模块来自工作中的？？？
常用的c++特性--＞day02
m0_69093426的博客
11-06 517
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 187
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
西南科技大学C++作业1——组合依赖关系实验代码
m0_74312676的博客
11-05 597
合理设计类与类的组合关系，即一个类要嵌套另一个类的对象作为成员变量，根据问题的需要可以是同一个类的多个对象(可以使用对象数组)，也可以是不同类的多个不同对象。让所设计的功能发挥作用。对学生和图书进行抽象，抽象出应有的成员变量，和基本的初始化，修改等成员函数，学生可以发起借书的操作，这是一种依赖关系，在学生类中将设计相应的成员函数体现这一功能操作，合理即可，可以用输出借书是否成功的结果，有一定示意就可以。其他操作：计算得到正确答案，输入自己的题目的答案，向题库内增加题目，在题库内删除题目，查询题库的题目。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 120
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
C++ | 表示移动函数move()的基本用法
brilliantgby_id的博客
11-09 185
通过函数定义可以看出，move函数没有进行移动操作，而是返回类型转换后的参数。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 476
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
【C语言】浮点型数据存储 和 整型数据存储的区别
猫猫的小茶馆
11-09 219
现在计算机中的浮点数存储都是遵循IEEE754/854标准，以二进制的科学计数法存放到内存中。“指数部分”，即次高有效的e个比特，存储指数部分；最后剩下的f个低有效位的比特，存储“有效数”（significand）的小数部分（在非规约形式下整数部分默认为0，其他情况下一律默认为1）。一定要很清楚数据在计算机的存储方式，知道数据布局可以帮助优化内存访问，提高程序运行效率；确保数据类型和大小正确，避免精度损失或数据截断；对于浮点数在计算机中有两种存储的精度，即单精度和双精度，单精度是32位，双精度是64位。
C/C++语言基础--C++模板与元编程系列四(类型模板参数、整数、指针 、模板类型)
最新发布
weixin_74085818的博客
11-09 532
💇 上面案例就是很简单的案例，定义了两个案例模板，后买你定义了一个打印数据的函数；前三掌已经讲解了函数、类、变量模板以及他们的特性等等，这一小节。这个部分前三章讲过，这里就不详细讲解了，总的来说就是，不用。要注意数据如何表示，输出的时候如何输出，即可；变量指针这个当然可以，上面案例也有，这里讲解。方法是在运行的时候确定的，不是在编译期间。：进一步说明了，模板参数兼容任意类型。，模板这个东西比较新，本人是在。原因原容易找到，这个在之前的。)，只需要加个运算符重载即可。☄ 这个是最常用的，就是用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值