C++对象优化

已于 2022-02-15 20:42:15 修改
阅读量218 收藏
点赞数
分类专栏： C++ 文章标签： c++
于 2021-08-24 10:31:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42500831/article/details/119870349
版权
本文深入探讨了C++中对象的优化策略，包括函数返回对象优化、类型转换时临时对象的生命周期、指针引用与临时对象的关系，以及构造析构顺序。同时，介绍了如何通过右值引用解决临时对象拷贝构造问题，提升程序效率。并举例说明了在vector等容器中应用移动语义的实现方式。
摘要由CSDN通过智能技术生成

函数返回对象优化

#include <iostream>

using namespace std;

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

int main() {
	Test t1;
	Test t2(t1);
	Test t3 = t1;
	// Test(20)显示生成临时对象  生命周期：所在语句
	// 被优化为 Test t4(20)
	Test t4 = Test(20);
	cout << "------------" << endl;
	return 0;
}

重点：用临时对象拷贝构造新对象的时候，临时对象不构造了，直接生成目标对象
在这里插入图片描述

类型转换时的临时对象

	// 这句调用operator=，必须生成临时对象，出了这条语句后，临时对象被析构
	t4 = Test(30);
	// 显式（生成临时对象）类型转换int->Test，编译器会查看Test是否存在一个合适的构造函数，存在就直接构造
	t4 = (Test)40;
	// 隐式（生成临时对象）类型转换int->Test，出了该语句就被析构
	t4 = 50;

指针、引用、临时对象

	// 出了这条语句后，临时对象被析构，ptr成为野指针
	Test* ptr = &Test(10);
	// 引用相当于给了临时对象一个名字，这个临时对象的生命周期延长为这个引用变量的周期
	const Test& ref = Test(10);

构造析构顺序

构造的时候先构造全局变量、然后进入函数顺序执行（执行到static时才初始化）
析构的时候，先析构局部变量，然后是static变量和全局变量

#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(const Test& src):ma(src.ma), mb(src.mb) {
		cout << "Test(const Test& src)" << endl;
	}
	void operator=(const Test& src) {
		cout << "operator=" << endl;
		ma = src.ma;
		mb = src.mb;
	}
	~Test() {
		cout << "~Test()" << endl;
	}
private:
	int ma;
	int mb;
};

// 全局变量最先初始化
Test t1(10, 10); // 1. Test(int, int)

int main() {
	Test t2(20, 20);  // 3. Test(int, int)
	Test t3 = t2;     // 4. Test(const Test& src)

	// static变量，运行到这条语句才初始化
	// 临时对象构造新对象，直接优化为构造目标对象 
	static Test t4 = Test(30, 30); // 5. Test(int, int)

	t2 = Test(40, 40);     // 6. Test(int, int)  operator=  ~Test()
	t2 = (Test)(50, 50);   // 7. Test(int, int)  operator=  ~Test()       逗号表达式 ：同t2 = (Test)50;
	t2 = 60;               // 8. Test(int, int)  operator=  ~Test()
	 
	Test* p1 = new Test(70, 70);   // 9. Test(int, int) 
	Test* p2 = new Test[2];        // 10. Test(int, int)  Test(int, int) 
	Test* p3 = &Test(80, 80);      // 11. Test(int, int)  ~Test()
	const Test& p4 = Test(90, 90); // 12. Test(int, int)

	delete p1;                     // 13. ~Test()
	delete[] p2;                   // 14. ~Test() ~Test()

	// 最后析构顺序：p4、t3、t2、t4、t5、t1（局部变量、静态变量、全局变量）
	return 0;
}

Test t5(10, 10); // 2. Test(int, int)

函数调用过程

#include <iostream>

using namespace std;

class Test {
public:
	Test(int a = 5) :ma(a){
		cout << "Test(int, int)" << endl;
	}
	Test(const Test& src):ma(src.ma){
		cout << "Test(const Test& src)" << endl;
	}
	void operator=(const Test& src) {
		cout << "operator=" << endl;
		ma = src.ma;
		// return *this;
	}
	~Test() {
		cout << "~Test()" << endl;
	}
	int get_data() {
		return ma;
	}
private:
	int ma;
};

// 返回值为Test*和Test&都不对，不能返回局部对象指针和引用(针对栈区数据，栈帧清退，对象销毁。指向堆区和数据区的指针可以返回)
Test get_obj(Test t) {      // 3. Test(const Test& src) 实参拷贝构造形参
	int val = t.get_data();
	Test tmp(val);          // 4. Test(int)
	                        // 5. Test(const Test& src) 用tmp在main函数栈帧上拷贝构造临时对象
							// 6. 析构tmp ~Test() 7. 析构形参t ~Test() 
	return tmp;
}

int main() {
	Test t1;              // 1. Test(int)
	Test t2;              // 2. Test(int)
	t2 = get_obj(t1);     // 8. t2.operator=(临时对象) 
						  // 9. 临时对象析构
						  // 10. t2析构、t1析构
	return 0;
}

优化后的代码：

Test get_obj(Test& t) {     
	return(t.get_data());
}

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

在这里插入图片描述

总结对象优化规则：

  1. 函数参数传递过程中，对象优先用引用传递，不要按值传递。避免实参形参的拷贝构造以及出作用域的析构
  2. 用临时对象拷贝构造一个新对象的时候，C++编译器直接优化为构造目标对象。所以被调用函数返回的时候直接返回临时对象即可（此时被调用函数的栈帧上不会产生临时对象，也就不用出作用域析构），无需先构造后返回。
  3. 接收一个对象返回值的时候，以初始化（拷贝构造）的方式接收，而不是以赋值的方式接收
#include <iostream>
using namespace std;

class String
{
public:
    String(const char* str = nullptr)
    {
        cout << "String(const char*)" << endl;
        if (str != nullptr)
        {
            m_data = new char[strlen(str) + 1];
            strcpy(m_data, str);
        }
        else
        {
            m_data = new char[1];
            *m_data = '\0';
        }
    }
    String(const String& src)
    {
        cout << "String(const String& src)" << endl;
        m_data = new char[strlen(src.m_data) + 1];
        strcpy(m_data, src.m_data);
    }
    ~String()
    {
        cout << "~String()" << endl;
        delete[]m_data;
        m_data = nullptr;
    }

    //调用String&是为了支持连续的operator=赋值操作
    String& operator=(const String& src)
    {
        cout << "operator=" << endl;
        if (&src == this)
        {
            return *this;
        }
        delete[]m_data;
        m_data = new char[strlen(src.m_data) + 1];
        strcpy(m_data, src.m_data);
        return *this;
    }

    const char* c_str() {
        return m_data;
    }
private:
    char* m_data;//用于保存字符串
};

String get_string(String& str) {
    const char* pstr = str.c_str();
    String tmp(pstr);
    return tmp;
}

int main(){
    String str1("11111111111111111");
    String str2;
    str2 = get_string(str1);
    cout << str2.c_str() << endl;
    return 0;
}
*/

在这里插入图片描述

使用右值引用解决临时对象拷贝构造等问题

	 // 临时对象（右值）会匹配到右值引用为参数的函数，这里的src是临时对象（右值）
    String(String&& src){
        cout << "String(const String&& src)" << endl;
        m_data = src.m_data;
        src.m_data = nullptr;
    }
    
    String& operator=(String&& src){
        cout << "operator=(String&& src)" << endl;
        if (&src == this)
        {
            return *this;
        }
        delete[]m_data;
        m_data = src.m_data; // 改变堆区资源指向
        src.m_data = nullptr; // 临时对象的指针置空，防止析构的时候释放资源
        return *this;
    }

vector上应用String
在这里插入图片描述

std::move：移动语义，得到右值类型
std::forward：类型的完美转发，得到真实的左/右值

函数模板的类型推演 + 引用折叠：

  1. String&& + && = String&&
  2. String& + && = String&
   //void construct(T* p, const T& val)//负责对象构造
    //{
    //    new(p)T(val);//定位new
    //}
    //void construct(T* p, T&& val)//负责对象构造
    //{
    //    new(p)T(std::move(val));//定位new
    //}
    

    template<typename Ty2>
    void construct(T* p, Ty2&& val)//负责对象构造
    {
        new (p) T(std::forward<Ty2>(val));//定位new
    }


	
    //void push_back(const T& val)//向容器末尾添加元素
    //{
    //    if (full())
    //        expand();
    //    //*_last++ = val;//last指针指向的内存构造一个值为val的对象
    //    _allocator.construct(_last, val);
    //    _last++;

    //}
    //void push_back(T&& val)//向容器末尾添加元素
    //{
    //    if (full())
    //        expand();
    //    //*_last++ = val;//last指针指向的内存构造一个值为val的对象
    //    _allocator.construct(_last, std::move(val));
    //    _last++;
    //}
    
    // 函数模板的类型推演 + 引用折叠
    // String&& + && = String&&
    // String& + && = String&
    // T char
    // Ty1 String

    template<typename Ty1> // 换个名会进行类型推演，直接用T直接断定是右值引用
    void push_back(Ty1&& val) {
        if (full()) {
            expand();
        }
        // forward：类型的完美转发
        _allocator.construct(_last, std::forward<Ty1>(val));
        _last++;
    }
    
    // 函数模板的类型推演 + 引用折叠
    // String&& + && = String&&
    // String& + && = String&
    template<typename Ty1>
    void push_back(Ty1&& val) {
        if (full()) {
            expand();
        }
        // forward：类型的完美转发
        _allocator.construct(_last, std::forward<Ty1>(val));
        _last++;
    }
bugcoder-9905
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++对象模型源码下载
02-14
理解C++对象模型对于深入学习C++、优化代码性能以及调试程序至关重要。在这个源码下载中，你可以探索这些概念的实际实现。 1. **对象的内存布局**：在C++中，每个对象都有一个特定的内存布局，包括成员变量和可能的...
C++性能优化技术
01-23
在C++的开发过程中，性能优化是一个非常关键的环节，它能够确保软件运行的效率和响应速度。以下是一些C++性能优化的重要知识点： 1. **算法优化**：优化算法是提升程序性能的根本方式。选择合适的数据结构和高效的...
542-C++对象的优化
LINZEYU666的博客
09-11 231
对象使用过程中背后调用了哪些方法 代码示例1 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&)" <<
【C++】对象优化
GoingJack博客
07-17 173
关于对象优化在我们开发的高效率的代码，有非常重要的作用。 首先我们学习对象使用的过程中背后调用了那些方法 现在我们有如下的测试类。 #include <iostream> using namespace std; class Test { public: Test(int a = 5, int b = 5) :ma(a), mb(b) { cout << "...
C++对象调用优化
最新发布
qq_45041871的博客
08-26 286
本文主要讲述了C++对象调用过程中可能存在的优化点，右值引用和左值引用，move和forward的使用方法，总结了函数调用过程中的优化过程，优化过程中体现在参数接受、返回对象和接收对象上，掌握这些才可以写出高性能的面向对象代码。
深度探索c++对象模型(2012版本)
02-07
总的来说，《深度探索C++对象模型》将带领读者深入C++的核心，理解对象模型的每一个细节，这对于提升C++编程技能，解决复杂问题和优化代码性能具有极大的价值。通过阅读本书，读者将能够更好地掌握C++这一强大工具，...
C++性能优化英文版
03-07
### C++性能优化知识点解析 #### 一、前言与背景 C++作为一种广泛应用于高性能计算领域的编程语言，其性能优化对于提升软件系统的整体效率至关重要。《Optimized C++》一书由Kurt Guntheroth编写，旨在为读者提供一...
总结c++性能优化策略
08-27
本篇文章总结了关于C++性能优化策略的相关知识点，涵盖了继承、对象的复合、构造函数、变量延时定义、虚函数、返回值优化、变量的定义、内存管理、内联、STL、缓存、延时计算、多线程、CPU缓存、内存对齐、函数参数...
(C++对象模型)：程序的优化
baidu_41388533的博客
09-18 154
程序的优化 #include <iostream> using namespace std; class CTempValue { public: int val1; int val2; public: CTempValue(int v1 = 0, int v2 = 0) :val1(v1), val2(v2) //构造函数 { cout << "调用了构造函数！" << endl; cout << "val1 = " <<
C++高级编程（一）——对象优化
yttt的博客
10-06 591
C++高级编程（一）——对象优化
C++对象构造和对象优化
weixin_39861267的博客
05-20 80
C++对象构造和优化
对象的优化
gaoyuelong的博客
05-21 130
class Test { public: Test(int a = 10) : ma(a) { cout << this << endl; cout << "constructor" << endl; //cout << __FUNCTION__ << endl; } ~Test() { cout << this << endl; cout << "destructor"
mysql数据库对象优化_[MySQL] 优化数据库对象
weixin_29441555的博客
02-04 96
在数据库设计的过程中，用户可能会有疑问：是否所有表都应该按照第三范式来设计？表中的字段设置多大长度合适？这些小问题，也需要谨慎对待，合理设计，此后也需要对MySQL中一些数据库对象进行优化。1、优化表的数据类型原则上，表需要使用何种数据类型是需要根据应用来判断的；需要有一些冗余，但是不推荐很多字段都有大量冗余。MySQL中，可以使用函数PROCEDURE ANALYSE()对当前的表进行分析，该函...
改善C++ 程序的150个建议学习之建议34：用智能指针管理通过new创建的对象
CodingAdo
09-16 1930
建议34：用智能指针管理通过new创建的对象 前面的建议中我们不厌其烦的一再重复：内存泄漏是一个很大很大的问题！为了应对这个问题，已经有许多技术被研究出来，比如Garbage Collection（垃圾回收）、Smart Pointer（智能指针）等。Garbage Collection技术一直颇受注目，并且在Java中已经发展成熟，成为内存管理的一大利器，但它在C++语言中的发展却不顺利，C+
C++中小对象内存分配的优化与封装
Zeeeitch
10-07 2883
<span lang="EN-US" style="font-size:10.5pt;color:black"> <p class="doctext" align="center" style="margin:0cm;margin-bottom:.0001pt;text-align:center">The Small Object Allocation Optimization
C++中对象或其对象指针的赋值
xzhch2012的专栏
11-21 819
C++中对象或其对象指针的赋值 C++中成员函数的动态绑定： C++中要实现函数的动态绑定，必须在其基类中将函数声明为virtual且在子类中对函数加以实现。然后用一个基类指针指向某一个子类对象，这样才会在函数调用时实现动态绑定。 在C++中，只有对象指针才有可能使用函数的动态绑定。所有对象实体所能够进行的操作都是静态绑定的。 C++中对象或其指针的赋值操作： 这是
[C++11]委托构造函数
m0_51955470的博客
06-18 173
委托构造函数允许使用同一个类中的一个构造函数调用其他的构造函数，从而简化相关变量的初始化。 注意点: 1.这种链式的构造函数调用不能形成一个闭环(死循环)，否则会在运行期抛异常。 2.如果要进行多层构造函数的链式调用，建议将构造函数的调用写在初始化列表中而不是函数体内部，否则编译器会提示形参的重复定义。 3.在初始化列表中调用了代理构造函数初始化某个类成员变量之后，就不能在初始化列表中再次初始化这个变量了。 代码如下: #include <iostream> using namespace st
深入理解C++对象模型
"《Inside the C++ Object Model》是Addison Wesley出版社的一部经典著作，专为深入理解C++对象模型的读者而准备。这本书深入探讨了支持C++面向对象编程的各种底层机制，包括构造函数的语义、临时对象的生成、封装的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

bugcoder-9905

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

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

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

打赏作者

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

抵扣说明：

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

余额充值