c++介绍智能指针 十二（1）

普通指针：指向内存区域的地址变量。使用普通指针容易出现一些程序错误。

如果一个指针所指向的内存区域是动态分配的，那么这个指针变量离开了所在的作用域，这块内存也不会自动销毁。动态内存不进行释放就会导致内存泄露。如果一个指针指向已经释放的区域，那么这个指针就是一个悬空指针，使用悬空指针会 造成不可预料的结果。定义了一个指针，却未初始化实际指向有效的内存区域，这个指针就成了野指针。使用野指针访问内存一般会造成段错误。

使用智能指针可以有效避免上述错误的发生。

智能指针：封装了动态对象指针的类对象。

 由于智能指针是一个对象，它封装了一个指向另一个对象的指针。当智能指针离开作用域后，会被自动销毁。销毁过程中会调用析构函数，来删除封装的对象。

标准的模板库中提供了以下几种智能指针。

unique_ptr

template<
class T,
class Deletr=std::std::default_delete<T>
>class unique_ptr
T是所封装的动态对象分配类型
Deleter是unique_ptr在释放它所管理的对象时，所使用的方法。一般我们使用默认值。

template<
class T,
class Deleter
>class unique_prt<T[],Deleter>
针对动态数组的特化版本。
以下是unique_ptr的常用函数。

T* get(); //获得所管理对象指针
T* operator->();//重载的间接运算符调用了get函数，也返回了所管理对象的指针，这样可以使用间接成员运算符来访问所管理的对象成员了
T& operator*();//重载的解引用运算符返回所管理的对象的引用，相当于*get()函数
T* release();//接触对封装对象的管理，返回对象的指针，这个对象指针脱离unique_ptr,c成为一个普通指针，用完这个指针需要手动释放。
void reset(T* newObject);//删除原有的对象，接管新的对象
void swap(unique_ptr<T>&other);与其他的unique_Ptr对象互换。

unique_ptr与它所管理的对象是动态一对一的关系，不能有两个unique_ptr对象指向同一个地址。

创建一个unique对象的方法是

unique_ptr<A>ptr1(new A(参数))
unique_ptr<A>ptr=make_unique<A>(参数)

 

#include<memory>
#include<iostream>

using namespace std;
class Rectangle
{
public:
	Rectangle(double w,double h):width(w),height(h) {}
	~Rectangle() { cout << "对象封装被释放" << endl; }
	double area()
	{
		return width * height;
	}
private:
	double width;
	double height;
};
int main()
{
	using std::unique_ptr;
	{
		unique_ptr<Rectangle>pDemo(new Rectangle(3,4));
		cout << pDemo->area() << endl;
	}
}

由于智能指针重载了间接成员运算符和解引用运算符，它们会返回智能指针所包含对象的指针或者引用，可以像使用普通指针一样使用智能指针。除了在离开当前作用域时会删除指针指向的对象，下面几种方法也会删除

unique_ptr<Rectangle>p1(new Rectangle(1, 1));
p1 = nullptr;

unique_ptr<Rectangle>p1(new Rectangle(1, 1));
unique_ptr<Rectangle>p2(new Rectangle(1, 1));
p1 = move(p2);

unique_ptr<Rectangle>p1(new Rectangle(1, 1));
p1.reset(new Rectangle(3, 7));

由于unique_ptrd对管理的资源具有独占性，所以unique_ptr不能被拷贝，也不能被赋值。不过可以对unique_ptr对象所管理对象所有权进行转移。

#include<memory>
#include<iostream>

using namespace std;
class Rectangle
{
public:
	Rectangle(double w,double h):width(w),height(h) {}
	~Rectangle() { cout << "对象封装被释放" << endl; }
	double area()
	{
		return width * height;
	}
private:
	double width;
	double height;
};
int main()
{
	unique_ptr<Rectangle>p1(new Rectangle(1,3));
	unique_ptr<Rectangle>p2 = move(p1);
	cout << p2->area() << endl;

}

 上述代码中通过move函数p2拥有了p1对象管理权。p1包含了一个空指针。这时可以通过p2来访问它所封装的对象成员了。

unique_ptr主要适合在使用在普通指针的地方，例如使用在容器上，

struct Packet
{
	Packet(long id) :m_id(id) {}
	long m_id;
	char Data[1000];
};
struct Compare {
	bool operator()(const Packet& a, const Packet& b)
	{
		return a.m_id < b.m_id;
	}
};
void sortValueVector(int n)
{
	vector<Packet>vecPacket;
	for (int i = 0; i < n; i++)
	{
		vecPacket.push_back(Packet(rand() % n));
	}
	sort(vecPacket.begin(), vecPacket.end(), Compare());
}

用vector装入n个Packet对象，然后对他进行排序。由于容器中装入的是对象，对于这种较大的对象，排序意味着大量数据进行移动复制，这样开销很大。如果将容器中的对象改为指针 ，排序时仅涉及到指针值的复制。那么效率会高很多。如下代码

struct Packet
{
	Packet(long id) :m_id(id) {}
	long m_id;
	char Data[1000];
};
struct Compare {
	bool operator()(const Packet* pA, const Packet* pB)
	{
		return pA->m_id < pB->m_id;
	}
};
void sortValueVector(int n)
{
	vector<Packet*>vecPacket;
	for (int i = 0; i < n; i++)
	{
		vecPacket.push_back(new Packet(rand() % n));
	}
	sort(vecPacket.begin(), vecPacket.end(), Compare());
}

使用指针的缺点是需要使用专门的代码对指针维护，当删除，替换时，需要释放不再使用的指针对象， 如果出现异常，提前返回等情况，容易造成内存泄露。如果将容器中的指针替换成unique_ptr,不仅获得接近普通性能的智能指针，还实现了内存资源的自动释放，不会出现意外的内存泄露情况。

下面这段代码中针对compare 类针对对象，指针，智能指针，三种情况下，排序所用时间

#include<memory>
#include<iostream>
#include<vector>
#include<algorithm>
#include<chrono>
using namespace std;
using namespace std::chrono;
struct Packet
{
	Packet(long id) :m_id(id) {}
	long m_id;
	char Data[1000];
};
struct Compare {
	bool operator()(const Packet& a, const Packet& b)
	{
		return a.m_id < b.m_id;
	}
	bool operator()(const Packet* pA, const Packet* pB)
	{
		return pA->m_id < pB->m_id;
	}
	//template<template<typename>typename SmartPtr>
	bool operator()(const unique_ptr<Packet>& pA, const unique_ptr<Packet>& pB)
	{
		return pA->m_id < pB->m_id;
	}
};
class AutoToTimer {
private:
	high_resolution_clock::time_point startTime;
	string description;
public:
	AutoToTimer(const char* desc) :description(desc) 
	{
		startTime = high_resolution_clock::now();
	}
	~AutoToTimer()
	{
		high_resolution_clock::time_point endTime = high_resolution_clock::now();
		auto duration = duration_cast<chrono::microseconds>(endTime - startTime).count();
		cout << description << ":" << duration << "ms" << endl;
	}
};
void sortValueVector(vector<int>ids)
{
	vector<Packet>vecPacket;
	for (auto id : ids)
	{
		vecPacket.push_back(Packet(id));
	}
	{ 
		AutoToTimer autoTimer("sortValueVector");
		sort(vecPacket.begin(),vecPacket.end(),Compare());
	}
}

void sortPointVector(vector<int>ids)
{
	vector<Packet*>vecPacket;
	for (auto id : ids)
	{
		vecPacket.push_back(new Packet(id));
	}
	{
		AutoToTimer autoTimer("sortPointPtr");
		sort(vecPacket.begin(), vecPacket.end(), Compare());
	}
}
template<typename SmartPtr>
void sortSmartPtrVector(vector<int>ids)
{
	vector<SmartPtr>vecPacket;
	for (auto id : ids)
	{
		vecPacket.push_back(SmartPtr(new Packet(id)));
	}
	{
		AutoToTimer autoTime("sortUniquePtrVector");
		sort(vecPacket.begin(),vecPacket.end(),Compare());
	}
}
int main()
{
	int n = 100000;
	vector<int>randomId{ n,0 };
	for (int i = 0; i < n; i++)
	{
		randomId.push_back(rand() % 100000);
	}
	sortValueVector(randomId);
	sortPointVector(randomId);
	sortSmartPtrVector<unique_ptr<Packet>>(randomId);
}

打印结果