C++高级编程（一）——对象优化

最新推荐文章于 2024-07-24 11:32:27 发布
最新推荐文章于 2024-07-24 11:32:27 发布
阅读量588 收藏 1
点赞数 1
分类专栏： # C++高级学习 文章标签： c++ c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41945053/article/details/127185764
版权

01 对象使用背后调用方法

#include "pch.h"
#include <iostream>
using namespace std;

class Test
{
public:
	// Test() Test(10) Test(10, 10)
	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, 10); // 1.Test(int, int)
int main()
{
	Test t2(20, 20); // 3.Test(int, int)
	Test t3 = t2; // 4.Test(const Test&)
	// static Test t4(30, 30);
	static Test t4 = Test(30, 30); // 5.Test(int, int)
	t2 = Test(40, 40); // 6.Test(int, int) operator= ~Test()
	// (50, 50) =  (Test)50; Test(int)
	t2 = (Test)(50, 50); // 7.Test(int,int) operator=  ~Test()
	t2 = 60; //Test(int) 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()
}
Test t5(100, 100); // 2.Test(int, int)

02 函数调用背后调用方法

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&)" << 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) 显示生成临时对象  生存周期：所在的语句
	/*
	C++编译器对于对象构造的优化：用临时对象生成新对象的时候，临时对象
	就不产生了，直接构造新对象就可以了
	*/
	Test t4 = Test(20); // Test t4(20);没有区别的！
	cout << "--------------" << endl;

	// t4.operator=(t2)
	t4 = t2;
	// t4.operator=(const Test &t)
	// 显式生成临时对象
	t4 = Test(30);
	t4 = (Test)30; // int->Test(int)

	// 隐式生成临时对象
	t4 = 30; // Test(30) int->Test(int)    char*->Test(char*)

	cout << "--------------" << endl;
	Test *p = &Test(40);
	// p指向的是一个已经析构的临时对象
	const Test &ref = Test(50);
	cout << "--------------" << endl;
	return 0;
}

03 对象优化规则

  1. 函数参数传递过程中，对象优先按引用传递，不要按值传递
  2. 函数返回对象的时候，应该优先返回一个临时对象，而不要返回一个定义过的对象
  3. 接收返回值是对象的函数调用的时候，优先按初始化的方式接收，不要按赋值的方式接收
#include "pch.h"
#include <iostream>
using namespace std;

class Test
{
public:
	// Test()  Test(20)
	Test(int data = 10) :ma(data)
	{
		cout << "Test(int)" << endl;
	}
	~Test()
	{
		cout << "~Test()" << endl;
	}
	Test(const Test &t):ma(t.ma)
	{
		cout << "Test(const Test&)" << endl;
	}
	void operator=(const Test &t)
	{
		cout << "operator=" << endl;
		ma = t.ma;
	}
	int getData()const { return ma; }
private:
	int ma;
};
// 不能返回局部的或者临时对象的指针或引用

Test GetObject(Test &t) 
{
	int val = t.getData();
	/*Test tmp(val);
	return tmp;*/
	// 返回临时对象
	return Test(val); 
}
int main()
{
	Test t1;
	Test t2 = GetObject(t1);
	//t2 = GetObject(t1);
	return 0;
}

04 CMyString在Vector上的应用

#include <iostream>
#include <vector>
using namespace std;

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(CMyString &&str)
	{
		cout << "CMyString(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=(CMyString&&)" << endl;
		if (this == &str)
			return *this;

		delete[]mptr;

		mptr = str.mptr;
		str.mptr = nullptr;
		return *this;
	}
	const char* c_str()const { return mptr; }
private:
	char *mptr;
};

vector<CMyString> GetVector()
{
	CMyString str1 = "aaa", str2 = "bbb", str3 = "ccc";
	cout << "------------------------" << endl;

	vector<CMyString> vec;
	vec.reserve(10);
	vec.push_back(std::move(str1));
	vec.push_back(std::move(str2));
	vec.push_back(std::move(str3));

	return vec; // 匹配的是容器的右值引用参数的拷贝构造
}
int main()
{
	vector<CMyString> vec;
	
	vec = GetVector(); // 匹配的是容器的右值引用参数的赋值函数

	return 0;
}

05 move移动语义和forward完美转发

move(左值)：移动语义，得到右值类型 (int&&)a

forward:类型完美转发，能够识别左值和右值类型

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

#include <iostream>
//#include <vector>
using namespace std;

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(CMyString &&str) // str引用的就是一个临时对象
	{
		cout << "CMyString(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=(CMyString&&)" << endl;
		if (this == &str)
			return *this;

		delete[]mptr;

		mptr = str.mptr;
		str.mptr = nullptr;
		return *this;
	}
	const char* c_str()const { return mptr; }
private:
	char *mptr;

	friend CMyString operator+(const CMyString &lhs,
		const CMyString &rhs);
	friend ostream& operator<<(ostream &out, const CMyString &str);
};
CMyString operator+(const CMyString &lhs,
	const CMyString &rhs)
{
	//char *ptmp = new char[strlen(lhs.mptr) + strlen(rhs.mptr) + 1];
	CMyString tmpStr;
	tmpStr.mptr = new char[strlen(lhs.mptr) + strlen(rhs.mptr) + 1];
	strcpy(tmpStr.mptr, lhs.mptr);
	strcat(tmpStr.mptr, rhs.mptr);
	//delete []ptmp;
	return tmpStr; // 
	//return CMyString(ptmp);
}
ostream& operator<<(ostream &out, const CMyString &str)
{
	out << str.mptr;
	return out;
}

template<typename T>
struct Allocator
{
	T* allocate(size_t size) // 负责内存开辟
	{
		return (T*)malloc(sizeof(T) * size);
	}
	void deallocate(void *p) // 负责内存释放
	{
		free(p);
	}
	/*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 Ty>
	void construct(T *p, Ty &&val)
	{
		new (p) T(std::forward<Ty>(val));
	}
	void destroy(T *p) // 负责对象析构
	{
		p->~T(); // ~T()代表了T类型的析构函数
	}
};

/*
容器底层内存开辟，内存释放，对象构造和析构，都通过allocator空间配置器来实现
*/
template<typename T, typename Alloc = Allocator<T>>
class vector
{
public:
	vector(int size = 10)
	{
		// 需要把内存开辟和对象构造分开处理
		//_first = new T[size];
		_first = _allocator.allocate(size);
		_last = _first;
		_end = _first + size;
	}
	~vector()
	{
		// 析构容器有效的元素，然后释放_first指针指向的堆内存
		// delete[]_first;
		for (T *p = _first; p != _last; ++p)
		{
			_allocator.destroy(p); // 把_first指针指向的数组的有效元素进行析构操作
		}
		_allocator.deallocate(_first); // 释放堆上的数组内存
		_first = _last = _end = nullptr;
	}
	vector(const vector<T> &rhs)
	{
		int size = rhs._end - rhs._first;
		//_first = new T[size];
		_first = _allocator.allocate(size);
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; ++i)
		{
			//_first[i] = rhs._first[i];
			_allocator.construct(_first + i, rhs._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
	}
	vector<T>& operator=(const vector<T> &rhs)
	{
		if (this == &rhs)
			return *this;

		//delete[]_first;
		for (T *p = _first; p != _last; ++p)
		{
			_allocator.destroy(p); // 把_first指针指向的数组的有效元素进行析构操作
		}
		_allocator.deallocate(_first);

		int size = rhs._end - rhs._first;
		//_first = new T[size];
		_first = _allocator.allocate(size);
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; ++i)
		{
			//_first[i] = rhs._first[i];
			_allocator.construct(_first + i, rhs._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
		return *this;
	}
	void pop_back() // 从容器末尾删除元素
	{
		if (empty())
			return;
		//--_last; // 不仅要把_last指针--，还需要析构删除的元素
		--_last;
		_allocator.destroy(_last);
	}
	T back()const // 返回容器末尾的元素的值
	{
		return *(_last - 1);
	}
	bool full()const { return _last == _end; }
	bool empty()const { return _first == _last; }
	int size()const { return _last - _first; }

	//
	/*void push_back(const T &val) // 接收左值
	{
		if (full())
			expand();

		_allocator.construct(_last, val);
		_last++;
	}

	void push_back(T &&val) // 接收右值 一个右值引用变量本身还是一个左值
	{
		if (full())
			expand();

		_allocator.construct(_last, std::move(val));
		_last++;
	}*/
	// void push_back(CMyString &val)
	// CMyString&& + && = void push_back(CMyString&&val)
	template<typename Ty> // 函数模板的类型推演 + 引用折叠
	void push_back(Ty &&val) //Ty CMyString& + && = CMyString&
	{
		if (full())
			expand();

		// move(左值)：移动语义，得到右值类型   (int&&)a
		// forward:类型完美转发，能够识别左值和右值类型
		_allocator.construct(_last, std::forward<Ty>(val));
		_last++;
	}
private:
	T *_first; // 指向数组起始的位置
	T *_last;  // 指向数组中有效元素的后继位置
	T *_end;   // 指向数组空间的后继位置
	Alloc _allocator; // 定义容器的空间配置器对象

	void expand() // 容器的二倍扩容
	{
		int size = _end - _first;
		//T *ptmp = new T[2 * size];
		T *ptmp = _allocator.allocate(2 * size);
		for (int i = 0; i < size; ++i)
		{
			//ptmp[i] = _first[i];
			_allocator.construct(ptmp + i, _first[i]);
		}
		//delete[]_first;
		for (T *p = _first; p != _last; ++p)
		{
			_allocator.destroy(p);
		}
		_allocator.deallocate(_first);
		_first = ptmp;
		_last = _first + size;
		_end = _first + 2 * size;
	}
};

int main()
{
	CMyString str1 = "aaa";
	vector<CMyString> vec;

	cout << "-----------------------" << endl;
	vec.push_back(std::move(str1)); // CMyString&
	vec.push_back(CMyString("bbb"));   // CMyString&& move  forword
	cout << "-----------------------" << endl;

	return 0;
}
-特立独行的猪-
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
C++编程惯用法——高级程序员常用方法和技巧.rar
04-08
在C++编程中，掌握高级程序员常用的方法和技巧是提升编程效率、...以上只是C++高级编程中的一部分关键知识点，实际的学习资料可能包含更多细节和案例。深入理解和实践这些内容，将有助于你成为一位优秀的C++程序员。
C++编程惯用法——高级程序员常用方法和技巧
01-21
本资料《C++编程惯用法——高级程序员常用方法和技巧》旨在帮助开发者深入理解和掌握C++中的高级技术，使代码更加专业且高效。 1. **面向对象编程**： - **封装**：理解类的概念，封装数据和行为，以提高代码的...
C++对象优化
qq_41721746的博客
09-09 242
高效的C++编程---对象优化 1. 对象使用过程中背后调用了哪些方法 2. 函数调用过程中对象背后调用的方法 3. 对象优化的规则 4. CMyString 5.move和forward
【C++】对象优化
GoingJack博客
07-17 169
关于对象优化在我们开发的高效率的代码，有非常重要的作用。 首先我们学习对象使用的过程中背后调用了那些方法 现在我们有如下的测试类。 #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 268
本文主要讲述了C++对象调用过程中可能存在的优化点，右值引用和左值引用，move和forward的使用方法，总结了函数调用过程中的优化过程，优化过程中体现在参数接受、返回对象和接收对象上，掌握这些才可以写出高性能的面向对象代码。
(C++对象模型)：程序的优化
baidu_41388533的博客
09-18 149
程序的优化 #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++ Builder 5高级编程技术——GUI编程
12-20
C++ Builder 5提供了VCL（Visual Component Library）库，这是一个面向对象的组件库，使得GUI开发变得更加高效和便捷。 在C++ Builder 5中，GUI编程主要通过以下几种技术实现： 1. **VCL组件**：VCL包含了许多预定...
c++高级参考手册——pdf高清版
04-29
《C++高级参考手册》是一本深入探讨C++编程语言的专业书籍，对于想要掌握C++高级特性的开发者来说，无疑是一份宝贵的资源。该书涵盖了C++的基础知识以及一些深层次的概念，旨在帮助读者理解并熟练运用C++进行软件...
C++编译器对于对象的优化
qq_42120843的博客
05-09 809
用临时对象生成新对象时， 临时对象就不产生了，直接构造新对象即可。，将会节省一次的拷贝构造和析构的开销，原来t要拷贝构造和析构。输出结果又少了一对构造临时对象的构造和析构。函数返回对象的时候，应该优先返回一个。接收返回值是对象的函数调用，优先按。函数参数传递过程中，对象优先按。方式接收，不要按赋值方式接收。将上面的代码函数形参做修改为。而不是返回一个定义过的对象。可以发现少了两次的调用。
C++ 对象使用优化
weixin_40533189的博客
01-23 176
对象的生命周期 例子1: class Test { public: Test(int a= 10) :ma(a) { cout << "Test()" <<endl; } ~Test() { cout << "~Test()" <<endl; } Test(const Test
542-C++对象的优化
LINZEYU666的博客
09-11 226
对象使用过程中背后调用了哪些方法 代码示例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++ 对象应用优化的几点总结
qq_53111905的博客
12-30 352
C++ 对象应用优化 文章目录C++ 对象应用优化编译器的优化三条对象优化的规则右值引用优化 —— 移动拷贝构造、移动赋值重载move语义 与 forward完美转发 编译器的优化 /* C++编译器对于对象构造的优化：用临时对象生成新对象的时候，临时对象 就不产生了，直接构造新对象就可以了 */ Test t4 = Test(20); // 显式生成临时对象 t4 = Test(30); t4 = (Test)30; // int->Test(int) // 隐式生成临时对象
c++高级知识总结------01
qq_46615150的博客
06-24 149
文章目录一：对象应用优化二：添加带右值引用参数的拷贝构造和赋值函数三：通过自定义vector和string来理解move和forward 一：对象应用优化 1.1、c++编译器对于对象的构造的优化：用临时对象生成新对象的时候，临时对象就不产生了，直接构造新对象就可以了 例： Test t1 = Test(20); //与Test t1(20)没有区别 1.2、示例： Test t1 = Test(20); t1 = Test(30);//该语句会调用t1.operator=(const Test&
C++对象的优化--减少不必要的函数调用
乐行僧的博客
11-21 577
测试环境：win10+vs2013 初始代码： #include <iostream> using namespace std; class Test { private: int ma; public: Test(int data = 10) :ma(data) { cout << "Test(int)" << endl; } Test(const Test& t) :ma(t.ma) { cout << "Test(const
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1183
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1126
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
VS2019编译和使用gtest测试（C++）
最新发布
m0_65635427的博客
07-24 266
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
C++：兼收并蓄的编程语言——从基础到面向对象
C++语言，全称为C with Classes，是一种在C语言基础上发展起来的高级编程语言，由Bjarne Stroustrup于1983年创立。C++的设计目标是提供一个更加强大、灵活且面向对象的编程环境，同时保持C语言的高效性和灵活性。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

-特立独行的猪-

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

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

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

打赏作者

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

抵扣说明：

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

余额充值