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);
}

打印结果