【cpp---＞智能指针】

已于 2023-07-13 10:50:17 修改
阅读量500 收藏 2
点赞数 2
文章标签： c++ 数据结构
于 2023-07-06 16:21:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kk1125778230/article/details/131550113
版权

文章目录

一、为什么要有智能指针

在new/malloc/fopen/lock与对应的delete/free/fclose/unlock操作之间使用抛异常,可能会造成内存泄漏的问题,当然了也可以使用异常的重新抛出来解决此类问题,但是如果有大量的资源申请和释放操作,使用重新抛出异常会非常繁琐且代码冗余.智能指针可以很好的解决这个问题.

#include<iostream>
using namespace std;
int Division(int a, int b) {return b == 0 ? throw "除0错误" : a = a / b; }
void func()
{
	int* a1 = new int(1);
	int* a2=nullptr;
	//a2在new的时候就可能抛异常,造成开辟空间成功的a1内存未释放
	//,所以处理一下a2抛异常时a1的资源释放
	try{ a2 = new int(2); }
	catch (...) { delete a1; throw; }
	//division可能抛异常,造成开辟空间成功的a1和a2内存未释放
	//,所以处理一下a1和a2资源释放再抛出
	try { Division(*a1, *a2); }
	catch (...) { delete a1; delete a2; throw; }
	delete a1;
	delete a2;
}
int main()
{
	try{ func(); }
	catch (const char* str) { cout << str << endl; }
	catch (...) { cout << "未知异常" << endl; }
	return 0;
}

二、智能指针的原理

1.智能指针基本结构

智能指针,学术名:RAII(Resource Acquisition Is Initialization)资源获取即初始化,是一种利用对象生命周期来控制资源的简单技术.是用封装指针,构造时保存指针,析构时释放资源的一个类来实现的,这样就不会发生因为异常跳过释放资源的代码,造成内存泄漏问题了.

#include<iostream>
using namespace std;
template <class T>
class smart_ptr
{
public:
	smart_ptr(const T* ptr) :_ptr(ptr) {}
	解引用可以使用操纵符重载来实现,
	T& operator*() { return *_ptr; }
	T* operator->() { return &*_ptr; }
	~smart_ptr() { delete _ptr; }
private:
	T* _ptr;
};
int Division(int a, int b) { return b == 0 ? throw "除0错误" : a = a / b; }
void func()
{
	//如果因为异常跳出了此作用域,对象会调用析构自动释放资源
	smart_ptr<int> a1(new int(1));
	smart_ptr<int> a2(new int(2));
	cout << Division(*a1, *a2) << endl;
}
int main()
{
	try { func(); }
	catch (const char* str) { cout << str << endl; }
	catch (...) { cout << "未知异常" << endl; }
	return 0;
}

2.智能指针的拷贝和赋值

智能指针解决了资源释放的问题,但是还要有原生指针的使用方法和功能,这就需要解决指针的解引用,拷贝和赋值问题
浅拷贝问题
如果不自定义拷贝构造函数,就会发生两个对象同时使用一个指针指向的空间,会析构两次造成程序崩溃.这个问题可以使用引用计数的思想解决,但是引用计数的具体实现也是个问题,如果使用静态变量做引用计数会造成所有对象使用同一个计数器,是不正确的,因为不同的对象可能使用的是同一个指针,但是也有可能不同对象使用的是不同的指针,这时计数器的值肯定也是不同的.

void func()
{
	//如果因为异常跳出了此作用域,对象会调用析构自动释放资源
	smart_ptr<int> a1(new int(1));
	smart_ptr<int> a2(a1);
	cout << Division(*a1, *a2) << endl;
}

auto_ptr
C++98版本的库中就提供了auto_ptr的智能指针,auto_ptr的实现原理：管理权转移的思想，但是这个智能指针是不被推广,它的原理是:a1和a2两个对象,a2用a1构造,a1的指针赋值给a2,a1直接置空,这样做坑能会导致a1被错误的使用.

class auto_ptr
	{
	public:
		auto_ptr(T* ptr) :_ptr(ptr) {}
		
		//管理权转移
		auto_ptr(auto_ptr& ap) :_ptr(ap._ptr)
		 { ap._ptr = nullptr; }
		 
		 auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			if (this != &ap)
			{
				if (_ptr)
					delete _ptr;

				_ptr = ap._ptr;
				ap._ptr = nullptr;
			}

			return *this;
		}

		~auto_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
			}
		}
		T& operator*() { return *_ptr; }
		T* operator->() { return &*_ptr; }
	private:
		T* _ptr;
	};

unique_ptr
后来boost库提供了一些更好用的智能指针scoped_ptr/shared_ptr/weak_ptr,boost库是出++标准库的扩展库,它是一个可移植的库,作为c++的标准库的后备,是c++标准化进程的开发引擎之一.后来c++11将boost库中的智能指针吸收了,增加了更好用的智能指针unique_ptr,shared_ptr,weak_ptr.unique_ptr智能指针的实现思想是防止拷贝,在不需要拷贝的场景下可以使用这个智能指针.

template <class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr) :_ptr(ptr) {}
		//强制不允许拷贝
		unique_ptr(unique_ptr& ap) = delete;
		//强制不允许赋值
		unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete
		T& operator*() { return *_ptr; }
		T* operator->() { return &*_ptr; }
		~unique_ptr() { delete _ptr; }
	private:
		T* _ptr;
	};

shared_ptr
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源

  1. shared_ptr在其内部，每分资源拿到的资源地址和计数器的地址是相同的,用来记录该份资源被几个对象共享,其中的一个对象对计数器加或者减,其他对象的计数器都会被改变。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
#include<iostream>
using namespace std;

namespace kk
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr), _pcount(new int(1))
		{}
		//引用加
		void release()
		{
			if (-- (* _pcount) == 0)
			{
				cout << "delete _ptr" << endl;
				delete _ptr;
				delete _pcount;
			}
		}
		//引用减
		void addCount()
		{
			++(*_pcount);
		}
		//拷贝构造
		shared_ptr(const shared_ptr& sp)
			:_ptr(sp._ptr), _pcount(sp._pcount)
		{
			addCount();
		}
		//拷贝赋值
		shared_ptr<T>& operator=(const shared_ptr& sp)
		{
			//当使用自己给自己赋值,或者自己给自己的拷贝者赋值不处理.
			if (_ptr != sp._ptr)
			{
				//被赋值相当于赋值前的_ptr少了一个使用者所以--
				release();
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				//赋值后的_ptr多了一个使用者所以++
				addCount();
			}
		}
		T& operator*() { return *_ptr; }
		T* operator->() { return &(*_ptr); }
		~shared_ptr()
		{
			release();
		}
	private:
		T* _ptr;
		int* _pcount;
	};
	int Division(int a, int b)
	{
		b == 0 ? throw "除0错误" : a = a / b;
		return a; 
	}
	void func()
	{
		//如果因为异常跳出了此作用域,对象会调用析构自动释放资源
		shared_ptr<int> a1(new int(10));
		shared_ptr<int> a2(new int(0));
		cout << Division(*a1, *a2) << endl;
	}
}
int main()
{
	try { kk::func(); }
	catch (const char* str) { cout << str << endl; }
	catch (...) { cout << "未知异常" << endl; }
	return 0;
}

3.引用计数线程安全问题

当同一个智能指针被两个以上的线程使用时,线程内部同时拷贝智能指针,会造成线程同时加加同一个引用计数,引用计数达不到逾期的值,析构时引用计数在最后一个对象没有析构时就已经减到了0调用了delete,造成二次delete.所以引用计数使用时要加锁,shared_ptr智能指针要增加一个mutex对象,mutex对象成员必须是指针,否者无法实现同一个对象使用同一个资源.在调用delete以后析构mutex对象,

#include<iostream>
#include<thread>
#include<mutex>
using namespace std;

namespace kk
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			: _ptr(ptr)
			, _pcount(nullptr)
			, _pmutex(nullptr)
		{
			if (_ptr)
			{
				_pmutex= new mutex;
				_pcount= new int(1);
			}
		}

		shared_ptr(const shared_ptr<T>& sp)
			: _ptr(sp._ptr)
			, _pcount(sp._pcount)
			, _pmutex(sp._pmutex)
		{
			if (_pCount)
				addCount();
		}
		//引用加
		void release()
		{
			
			_mtx->lock();
			bool mutexflag = false;
			if (-- (* _pcount) == 0)
			{
				cout << "delete _ptr" << endl;
				delete _ptr;
				delete _pcount;
				mutexflag = true;
			}
			_mtx->unlock();
			if (mutexflag)delete _mtx;
		}
		//引用减
		void addCount()
		{
			_mtx->lock();
			++(*_pcount);
			_mtx->unlock();
		}
		//拷贝构造
		shared_ptr(const shared_ptr& sp)
			:_ptr(sp._ptr), _pcount(sp._pcount),_mtx(sp._mtx)
		{
			addCount();
		}
		//拷贝赋值
		shared_ptr<T>& operator=(const shared_ptr& sp)
		{
			//当使用自己给自己赋值,或者自己给自己的拷贝者赋值不处理.
			if (_ptr != sp._ptr)
			{
				//被赋值相当于赋值前的_ptr少了一个使用者所以--
				release();
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				_mtx = sp._mtx;
				//赋值后的_ptr多了一个使用者所以++
				addCount();
			}
			return *this;
		}
		T& operator*() { return *_ptr; }
		T* operator->() { return &(*_ptr); }
		T* getPtr()
		{
			return _ptr;
		}
		int getPcount()
		{
			return *_pcount;
		}
		~shared_ptr()
		{
			release();
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _mtx;
	};
	struct Date
	{
		int year = 0;
		int month = 0;
		int day = 0;
		~Date()
		{}
	};
	void thread_func(const shared_ptr<Date>& sp,size_t n)
	{
		for (size_t i = 0; i < n; i++)
		{
			shared_ptr<Date> copy(sp);
		}
	}
	void test_thread_safe()
	{
		size_t n = 10000;
		kk::shared_ptr<Date> sp(new Date);
		thread t1(thread_func, ref(sp), n);
		thread t2(thread_func, ref(sp), n);
		//连接线程回收资源,防止主线程先结束.
		t1.join();
		t2.join();
	}
}
int main()
{
	try { kk::test_thread_safe(); }
	catch (const char* str) { cout << str << endl; }
	catch (...) { cout << "未知异常" << endl; }
	return 0;
}

4.循环引用

智能指针有些场景会造成循环引用的,循环引用,就是两个智能指针相互依赖,释放时互相制约,形成引用死循环,资源无法被释放,造成内存泄漏.以链表节点的链接为例,两个节点相连,节点1的next链接节点2,节点2的pre链接节点1,这两个节点的指针以及节点内部的指针都用希尔智能指针,这时节点1和节点2的引用计数都是2,出作用域时,节点2引用计数-1,节点1的引用计数-1,但是这两个节点都无法释放,因为节点1的释放需要节点2的pre先释放—>pre需要节点2先释放—>节点2需要节点1的next先释放—>next释放需要节点1先释放 weak_ptr智能指针可以解决这个问题,它的特点就是不管理资源,不增加引用计数,支持shared_ptr类型的拷贝构造.

	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr) {}
		//拷贝构造
		weak_ptr(shared_ptr<T>& sp)
			:_ptr(sp.getPtr())
		{}
		T& operator*() { return *_ptr; }
		T* operator->() { return &(*_ptr);}
		T* getPtr()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
	template <class T>
	struct listNode
	{
		weak_ptr<listNode> next;
		weak_ptr<listNode> pre;
		T _data=0;
	};
	void test()
	{
		shared_ptr<listNode<int>> l1(new listNode<int>);
		shared_ptr<listNode<int>> l2(new listNode<int>);
		l1->next = l2;
		l2->pre = l1;
	}

5.定制删除器

智能指针越有可能会是new的多个空间,所以不能将析构中的delete写死,多增加一个构造函数,用来接收定制删除器,定制删除器是一个根据智能指针的实际情况来特定释放方式的仿函数.析构时使用仿函数对象析构,所以要增加一个包装器对象成员,用来保存构造时接收的仿函数对象,供析构时使用,但是如果没有传递定制器,那么析构也需要默认的析构方式,所以包装器对象需要一个lambda,参数为智能指针类型,函数体默认空间的释放方式.

#include<iostream>
#include<thread>
#include<mutex>
#include<functional>
using namespace std;

namespace kk
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr=nullptr)
			:_ptr(ptr), _pcount(new int(1)),_mtx(new mutex)
		{}
		template <class D>
		shared_ptr(T* ptr ,D del)
			: _ptr(ptr), _pcount(new int(1)), _mtx(new mutex),_del(del)
		{}
		//引用加
		void release()
		{
			_mtx->lock();
			bool mutexflag = false;
			if (-- (* _pcount) == 0)
			{
				if (_ptr)_del(_ptr);
				delete _pcount;
				mutexflag = true;
			}
			_mtx->unlock();
			if (mutexflag)delete _mtx;
		}
		//引用减
		void addCount()
		{
			_mtx->lock();
			++(*_pcount);
			_mtx->unlock();
		}
		//拷贝构造
		shared_ptr(const shared_ptr& sp)
			:_ptr(sp._ptr), _pcount(sp._pcount),_mtx(sp._mtx)
		{
			addCount();
		}
		//拷贝赋值
		shared_ptr<T>& operator=(const shared_ptr& sp)
		{
			//当使用自己给自己赋值,或者自己给自己的拷贝者赋值不处理.
			if (_ptr != sp._ptr)
			{
				//被赋值相当于赋值前的_ptr少了一个使用者所以--
				release();
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				_mtx = sp._mtx;
				//赋值后的_ptr多了一个使用者所以++
				addCount();
			}
			return *this;
		}
		T& operator*() { return *_ptr; }
		T* operator->() { return &(*_ptr); }
		T* getPtr()
		{
			return _ptr;
		}
		int getPcount()
		{
			return *_pcount;
		}
		~shared_ptr()
		{
			release();
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _mtx;
		function<void(T*)> _del=[](T* ptr) {
			cout << "delete _ptr" << endl;
			delete ptr; 
			};
	};
	struct Date
	{
		int year = 0;
		int month = 0;
		int day = 0;
		~Date()
		{}
	};
	struct DateDelete
	{
		void operator()(Date* d)
		{
			cout << "delete[] d" << endl;
			delete[] d;
		}
	};
	void test()
	{
		//以为析构顺序是3,2,1,sp3和sp2不会调用_del(_ptr),
		///只有sp1才会调用,所以拷贝构造和赋值构造不用拷贝包装器对象
		shared_ptr<Date> sp1(new Date[10], DateDelete());
		shared_ptr<Date> sp2(sp1);
		shared_ptr<Date> sp3(sp1);
		cout<<sp3.getPcount()<<endl;
		shared_ptr<Date> sp4(new Date[10], DateDelete()); 
	}
}
int main()
{
	try { kk::test(); }
	catch (const char* str) { cout << str << endl; }
	catch (...) { cout << "未知异常" << endl; }
	return 0;
}
kk1125778230
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CPP 智能指针总结分享
nongxiangge的博客
07-24 659
CPP 智能指针 shared_ptr、unique_ptr、weak_ptr 总结梳理分享
【Cpp】第十四章-智能指针
qq_41669298的博客
10-17 604
智能指针 基础概念 为什么要有智能指针   首先先看一段程序，看看这段程序可能会出现什么问题。 #include <iostream> using namespace std; void Func() { int* ptr = new int[10]; //...假设这其中有很多代码 throw "error!"; // delete[] ptr; } ...
cpp智能指针详解+简单模拟实现
m0_74358683的博客
04-18 209
有多个指针指向同一分内存时就要考虑使用shared_ptr了，shared_ptr的本质是采用引用计数的方式来记录有多少个指针指向这份空间，当发生拷贝或赋值时引用计数就++，shared_ptr析构时引用计数就--，只用当引用计数为0时才会释放空间。unique_ptr不允许复制和拷贝（可以移动构造和移动赋值）本质上就是一个unique_ptr管理一个内存空间(如果是多个指针指向同一份内存要用后面的shared_ptr)。由于它的构造和析构不会引起引用记数的增加或减少所以完美解决了循环引用的问题。
C++ 智能指针 - 全部用法详解
热门推荐
cpp_learner的博客
08-02 6万+
血的教训？不学智能指针，本人丢了一份工作。
cpp-httplib的下载和使用
limou3434的博客
04-18 1052
httplib是一个基于C++的轻量级HTTP框架，它提供了简单易用的API，用于创建HTTP服务器和客户端。
FFmpeg进行图像格式转换(cv::Mat ---＞＞YUV----＞＞AVFrame)
zhangyue123的博客
08-23 3231
opencv提供了rgb到yuv420的格式转换函数；下面给出基本用法。
27.C++- 智能指针
抵抗时间扭曲，坚持做一件有意义的事
04-11 1295
智能指针 在C++库中最重要的类模板之一 智能指针实际上是将指针封装在一个类里,通过对象来管理指针. STL中的智能指针auto_ptr 头文件: <memory> 生命周期结束时,自动摧毁指向的内存空间 不能指向堆数组(因为auto_ptr的析构函数删除指针用的是delete,而不是delete[]) auto_ptr的构造函数为explicit类型,所以只能显示初始化,比如...
Android 智能指针详解 -- RefBase
私房菜
12-21 1万+
源码基于：Android N 相关博文：Android 智能指针详解Android 智能指针详解 -- wp Android 智能指针详解 -- spAndroid 智能指针详解 -- RefBase 关于android 智能指针，前面详细分析了sp 和 wp的source code，但是还有一些疑问，在这一篇中全部解释，因为所有的源头都是来自于这里。更多信息可以看 sp的博文 和 wp的博文source code：system/core/include/utils/RefBase.hsystem/core
cpp-csmartpointersGNUC编程语言的智能指针
08-16
在GNU C++编程环境中，智能指针是一种非常重要的工具，它们是现代C++编程的核心特性之一，用于自动管理动态分配的内存。智能指针的概念旨在解决原始指针可能导致的内存泄漏和悬挂指针问题。本主题将深入探讨C++中的...
cpp-netlib-0.11.2-vs2013
09-06
该项目依赖于Boost库的1.59.0版本，这是一个广泛使用的C++库集合，提供了各种各样的功能，包括但不限于异常处理、智能指针、正则表达式、多线程支持以及I/O服务等。Boost库在cpp-netlib中的作用是提供基础的编程抽象...
cpp-CPPJWT实现JSONWebTokensJWT的C14库
08-16
为了使用这个库，你可能需要了解C++14的特性，如现代C++的智能指针、模板元编程和范围基础循环等。 在实际开发中，注意遵循JWT的最佳实践，比如使用安全的哈希算法，妥善保管密钥，以及正确处理JWT的过期和撤销。...
cpp-advanced-topics
03-19
在这个专题中，我们通常会深入探讨诸如模板元编程、STL（Standard Template Library）、智能指针、多线程、RAII（Resource Acquisition Is Initialization）原则、异常处理、函数对象（functors）以及自定义内存管理...
cpp-netlib
12-20
cpp-netlib与Boost的集成，使得开发者可以无缝地利用Boost的许多优势，例如智能指针、元编程工具、线程支持等。 cpp-netlib中的主要组件包括： 1. **HTTP服务器**：实现了HTTP/1.1协议，支持GET、POST和其他请求...
【C语言】函数
2402_85428625的博客
07-23 1306
1. 函数的概念 2. 库函数 2.1 标准库和头⽂件 2.2 库函数的使⽤⽅法 2.2.1 功能 2.2.2 头⽂件包含 2.2.3 实践 2.2.4 库函数⽂档的⼀般格式 3. ⾃定义函数 3.1 函数的语法形式 3.2 函数的举例 4. 形参和实参 4.1 实参 4.2 形参 4.3 实参和形参的关系 5. return语句 6. 数组做函数参数 7. 嵌套调⽤和链式访问 7.1嵌套调用 7.2 链式访问 8. 函数的声明和定义 8.1 单个⽂件 8.2 多个⽂件 8.3static 和 extern
C++---继承
最新发布
2302_80221042的博客
07-25 1243
我们之前学过类的访问限定符有这几种：
背单词工具(C++)
zeyeqianli的博客
07-24 3730
【代码】背单词工具(C++)
c＋＋初阶知识——string类详解
qq_58761784的博客
07-25 2076
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
C++的STL简介（一）
2302_81171591的博客
07-23 1434
STL（standarf template libaray-标准模板库）：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
#include "mainwindow.h" #include "ui_mainwindow.h" #include <QtWidgets> #include <QResizeEvent> //绘图区域大小变化事件 #include <QDebug> #include <QThread> #include <QTimer> #include <QVector> #include <QRandomGenerator> MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) , ui(new Ui::MainWindow) { ui->setupUi(this); ui->plot->setOpenGl(true); ui->plot->setNoAntialiasingOnDrag(true); CreateChart(); } MainWindow::~MainWindow() { delete ui; } void MainWindow::CreateChart() { ui->plot->addGraph(); ui->plot->graph(0)->setPen(QPen(QColor(100,149,237))); mData = ui->plot->graph(0)->data()->coreData(); ui->plot->xAxis2->setVisible(true); ui->plot->xAxis2->setTickLabels(false); ui->plot->yAxis2->setVisible(true); ui->plot->yAxis2->setTickLabels(false); connect(ui->plot->xAxis, SIGNAL(rangeChanged(QCPRange)), ui->plot->xAxis2, SLOT(setRange(QCPRange))); connect(ui->plot->yAxis, SIGNAL(rangeChanged(QCPRange)), ui->plot->yAxis2, SLOT(setRange(QCPRange))); ui->plot->setInteractions(QCP::iRangeDrag|QCP::iRangeZoom|QCP::iSelectPlottables); ui->plot->yAxis->setRange(-1.5,1.5); ui->plot->xAxis->setRange(0,50); ui->plot->yAxis->setLabel("数据"); ui->plot->xAxis->setLabel("个数"); for (int i = 0; i < 50; i++) { mXDataTol.append(i); mYDataTol.append(QRandomGenerator::global()->bounded(1.00)); } ui->plot->graph(0)->setData(mXDataTol,mYDataTol,true); ui->plot->replot(); }这是我的全部代码，系统报错：terminate called after throwing an instance of 'std::bad_alloc' what(): std::bad_alloc请帮我修改一下代码，我不知道到底哪里出了错
06-10
这个错误通常是由于内存不足导致的，也就是说程序尝试分配的内存超过了系统可用的内存。在你的代码中，我没有看到明显的内存泄漏或者内存溢出的问题。因此，我建议你尝试使用 Valgrind 等内存检测工具来检查你的程序是否存在内存问题。 此外，你可以尝试优化你的代码，减少内存的使用。具体来说，你可以考虑使用 QVector::reserve() 函数来预分配内存，避免频繁地动态分配和释放内存。例如： ```cpp mXDataTol.reserve(50); mYDataTol.reserve(50); for (int i = 0; i < 50; i++) { mXDataTol.append(i); mYDataTol.append(QRandomGenerator::global()->bounded(1.00)); } ``` 另外，你还可以使用 Qt 的智能指针类来管理内存，避免手动分配和释放内存。例如，你可以将 mData 声明为一个 QSharedPointer<QCPDataMap> 类型的智能指针，这样可以自动管理 mData 的内存，避免内存泄漏和悬挂指针的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值