普通指针：指向内存区域的地址变量。使用普通指针容易出现一些程序错误。
如果一个指针所指向的内存区域是动态分配的，那么这个指针变量离开了所在的作用域，这块内存也不会自动销毁。动态内存不进行释放就会导致内存泄露。如果一个指针指向已经释放的区域，那么这个指针就是一个悬空指针，使用悬空指针会 造成不可预料的结果。定义了一个指针，却未初始化实际指向有效的内存区域，这个指针就成了野指针。使用野指针访问内存一般会造成段错误。
使用智能指针可以有效避免上述错误的发生。
智能指针：封装了动态对象指针的类对象。
由于智能指针是一个对象，它封装了一个指向另一个对象的指针。当智能指针离开作用域后，会被自动销毁。销毁过程中会调用析构函数，来删除封装的对象。
标准的模板库中提供了以下几种智能指针。
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);
}打印结果
![[操作系统] 学校课程关于“静态优先级抢占式调度“作业](https://i-blog.csdnimg.cn/direct/d581fc77a7cd4facaf6b320a97f7cb2b.png)
