一 智能指针
1.1 手动初始化
注意:share_ptr<int> p = new int(10); //错误 share_ptr是explicit,不能进行隐式类型转换，只能直接初始化
1.1.1 make_shared
?
//功能：在堆区可以动态分配对象，并返回一个share_ptr(推荐，安全，高效)（构造方法初始化）
auto p = std::make_shared<string>("helloworld");
?
shared_ptr<int> p1 = make_shared<int>(5);
cout << *p1 << endl;
shared_ptr<string> ps = make_shared<string>("hello world");
cout << *ps << endl;
//手动初始化和使用make_shared函数模板初始化有什么区别？
//开销小，效率高（数据和引用计数存在同一个空间）
//构造函数初始化：数据和引用计数不再同一段空间，需要间接访问
?
shared_ptr<A> a1 = make_shared<A>();
shared_ptr<A> a2(a1);
1.2 常规操作
1.2.1 use_count()
功能：返回有多少个智能指针指向某个对象（引用计数的个数） 用途：主要用于调试
shared_ptr<A> a1 = make_shared<A>(); shared_ptr<A> a2(a1); cout << a2.use_count() << endl; ?//返回当前有多少个指针指向当前对象或者空间
1.2.2 unique();
功能:是否该智能指针独占某个对象，独占返回true,否则返回false;
if (a1.unique()) ?//判断当前指针是否独享（只有它自己指向该对象）或者空间
{
cout << "a1 is unique ptr" << endl;
}
1.2.3 reset
功能：判断当前指针是否独享该对象，如果独享，则释放该对象,否则将该指针置为NULL，并将引用计数器减一 用法：reset()或者reset(参数)
//判断当前指针是否独享该对象，如果独享，则释放该对象,并使该指针指向形参所对应的空间
a1.reset(new A(10));
//shared_ptr<A> pa(new A(188));
//a1.reset(pa);
cout << a1->m_a << endl;
1.2.4 解引用
获取智能指针指向的对象，并对其操作 get(); //获取智能指针中保存的裸指针。
shared_ptr<int> pd = make_shared<int>(5); Test(pd.get());
1.2.5 指定删除器
功能：有些情况，默认删除器处理不了（share_ptr管理的动态数组） 需要我们自己指定删除器，调用删除器函数释放空间
//指定删除器：当删除器不起作用的时候，需要自己指定删除器 void(*)(T*) //shared_ptr<A> pa(new A[3]); //delete pa --->应该是delete []pa; //shared_ptr<A[]> pa(new A[3]); //shared_ptr<A> pa(new A[3], Mydelete); shared_ptr<A> pa(new A[3], default_delete<A[]>());
1.2.6 lambda 表达式
shared_ptr<A> pa(new A[3], [](A*a) {
delete[]a; //lambda表达式
});
1.2.7 移动语义
shared_ptr<A> pa(new A(5)); const shared_ptr<A> &rpa = move(pa); //shared_ptr<A> &&rpa = move(pa); cout << "***************"<<endl; //pa = nullptr; cout << pa.use_count() << endl; cout << rpa.use_count() << endl;
#include <iostream>
#include <memory>
#include <string>
using namespace std;
class A
{
public:
A()
{
cout << "A的无参构造" << endl;
}
A(int n)
{
m_a = n;
cout << "A的有参构造" << endl;
}
~A()
{
cout << "A的析构函数" << endl;
}
public:
int m_a;
};
shared_ptr<A> test()
{
shared_ptr<A> temp(new A);
return temp;
}
void Func(shared_ptr<A> temp)
{
cout << temp->m_a << endl;
}
void Test(int *p)
{
}
void Mydelete(A *pa)
{
delete[]pa;
}
int main(void)
{
#if 0
//int *p = new int(5); //p是裸指针
//shared_ptr<int> p = new int(5); //初始化：调用类型转换构造函数 explicit
shared_ptr<int> p(new int(5));
cout << *p << endl;
shared_ptr<string> s(new string("helloworld"));
cout << *s << endl;
int num = 100;
//shared_ptr<int> p2(&num); //智能指针常用于堆空间，指向栈空间的时候，会导致内存释放两次
//A *pa = new A(100);
//delete pa;
shared_ptr<A> pa(new A);
shared_ptr<A> res = test();
Func(pa);
shared_ptr<A> pa2(pa);
//功能：在堆区可以动态分配对象，并返回一个share_ptr(推荐，安全，高效)（构造方法初始化）
auto p = std::make_shared<string>("helloworld");
shared_ptr<int> p1 = make_shared<int>(5);
cout << *p1 << endl;
shared_ptr<string> ps = make_shared<string>("hello world");
cout << *ps << endl;
//手动初始化和使用make_shared函数模板初始化有什么区别？
//开销小，效率高（数据和引用计数存在同一个空间）
//构造函数初始化：数据和引用计数不再同一段空间，需要间接访问
//常规操作：
shared_ptr<A> a1 = make_shared<A>();
shared_ptr<A> a2(a1);
cout << a2.use_count() << endl; //返回当前有多少个指针指向当前对象或者空间
if (a1.unique()) //判断当前指针是否独享（只有它自己指向该对象）或者空间
{
cout << "a1 is unique ptr" << endl;
}
a1.reset();
if (a1 == nullptr) //NULL:void*() 0
{
cout << "a1 is nullptr" << endl;
}
cout << a2.use_count() << endl;
//判断当前指针是否独享该对象，如果独享，则释放该对象,并使该指针指向形参所对应的空间
a1.reset(new A(10));
//shared_ptr<A> pa(new A(188));
//a1.reset(pa);
cout << a1->m_a << endl;
shared_ptr<int> pd = make_shared<int>(5);
Test(pd.get());
#endif
//指定删除器：当删除器不起作用的时候，需要自己指定删除器 void(*)(T*)
//shared_ptr<A> pa(new A[3]); //delete pa --->应该是delete []pa;
//shared_ptr<A[]> pa(new A[3]);
//shared_ptr<A> pa(new A[3], Mydelete);
//shared_ptr<A> pa(new A[3], default_delete<A[]>());
/*shared_ptr<A> pa(new A[3], [](A*a) {
delete[]a; //lambda表达式
});*/
shared_ptr<A> pa(new A(5));
const shared_ptr<A> &rpa = move(pa);
//shared_ptr<A> &&rpa = move(pa);
cout << "***************"<<endl;
//pa = nullptr;
cout << pa.use_count() << endl;
cout << rpa.use_count() << endl;
return 0;
}
1.3 auto_ptr
#include <iostream>
#include <memory>
using namespace std;
class Test
{
public:
Test()
{
cout << "Test的构造函数" << endl;
}
void print()
{
cout << "hello world" << endl;
}
~Test()
{
cout <<"Test的析构函数"<<endl;
}
};
void func1()
{
Test *pt = new Test;
}
void func2()
{
auto_ptr<Test> pt(new Test);
pt->print(); //pt.operator->(print());
}
int main(void)
{
func2();
func2();
}
1.4 weak_ptr
1.4.1 概念
弱指针：不会控制对象的生命周期（不会改变对象的引用计数）。 share_ptr释放指向对象时，是不会考虑weak_ptr是否指向该对象。 weak_ptr不是独立指针，不能单独操作所指向的资源。
1.4.2 作用
weak_ptr指针一般用来辅助share_ptr的使用（监视share_ptr指向对象的生命周期） weak_ptr和share_ptr可以相互转化，share_ptr可以直接赋值给weak_ptr 但是反过来是行不通的，需要使用lock函数。
1.4.3 常规操作
（1）lock函数
调用Lock函数用来获取share_ptr(如果对象已经被释放，则返回一个空的share_ptr)
shared_ptr<A> pa(new A(5));
pa.reset();
weak_ptr<A> wpa = pa;
auto pb = wpa.lock(); //将弱指针转为共享指针
if(nullptr == pb)
{
cout << "pb is nullptr" << endl;
}
else
{
cout << "pb is not nullptr" << endl;
}
（2）use_count
功能：返回有多少个weak_ptr智能指针指向对象（引用计数的个数） 用途：主要用于调试。
（3）expired
功能：判断弱指针是否过期（所检测的对象是否被释放 true /false）
//wpa.reset(); //弱引用计数-1,
cout << wpa.use_count() << endl; //返回的是weak_ptr的引用计数
cout << pb.use_count() << endl;
if (wpa.expired()) //判断当前弱指针指向的对象是否被释放，弱被释放，返回true,否则返回false
{
cout << "wpa poniter class is free" << endl;
}
(4) 循环引用
?
#include <iostream>
#include <memory>
#include <string>
using namespace std;
class Child;
class Parent;
class A
{
public:
A()
{
cout << "A的无参构造" << endl;
}
A(int n)
{
m_a = n;
cout << "A的有参构造" << endl;
}
~A()
{
cout << "A的析构函数" << endl;
}
public:
int m_a;
};
class Parent
{
public:
Parent()
{
cout << "Parent的构造函数" << endl;
}
~Parent()
{
cout << "parent的析构函数" << endl;
}
weak_ptr<Child> c;
};
class Child :public Parent
{
public:
Child()
{
cout << "Child的构造函数" << endl;
}
~Child()
{
cout << "Child的析构函数" << endl;
}
weak_ptr<Parent> p;
};
int main(void)
{
#if 0
//weak_ptr<A> wpa(new A(5)); //不能独立操作一块空间
shared_ptr<A> pa(new A(5));
//weak_ptr:类模板，弱指针（弱引用计数）
weak_ptr<A> wpa = pa;
weak_ptr<A> wpb = pa;
weak_ptr<A> wpc = pa; //弱引用不会影响其生命周期，无论多少个弱引用指向这段空间，只要强引用计数为0，则释放这段空间
//常规操作：
shared_ptr<Parent> pp(new Parent);
shared_ptr<Child> cc(new Child);
pp->c = cc;
cc->p = pp;
cout << "hello world" << endl;
#endif
shared_ptr<A> pa(new A(5));
//pa.reset();
weak_ptr<A> wpa = pa;
auto pb = wpa.lock(); //将弱指针转为共享指针
if(nullptr == pb)
{
cout << "pb is nullptr" << endl;
}
else
{
cout << "pb is not nullptr" << endl;
}
//wpa.reset(); //弱引用计数-1,
cout << wpa.use_count() << endl; //返回的是weak_ptr的引用计数
cout << pb.use_count() << endl;
if (wpa.expired()) //判断当前弱指针指向的对象是否被释放，弱被释放，返回true,否则返回false
{
cout << "wpa poniter class is free" << endl;
}
return 0;
}
(5) share_ptr & weak_ptr
尺寸：share_ptr 和 weak_ptr一样大，都是裸指针的两倍
?
#include <iostream>
#include <memory>
#include <string>
using namespace std;
class Child;
class Parent;
class A:public enable_shared_from_this<A>
{
public:
A()
{
cout << "A的无参构造" << endl;
}
A(int n)
{
m_a = n;
cout << "A的有参构造" << endl;
}
//A *GetAddr()
shared_ptr<A> GetAddr()
{
//return this;
//shared_ptr<A> tmp(this);
//return tmp;
//实现原理：
//其内部有一个weak_ptr类型的成员变量_wptr
//当shared_ptr构造的时候，如果其模板类型继承了enable_shared_from_this<T>，则堆_wptr进行初始化操作
//这样在调用shared_from_this（）的时候，就能通过weak_ptr构造出对应的shared_ptr
return shared_from_this(); //和pa共享其所有权
}
~A()
{
cout << "A的析构函数" << endl;
}
public:
int m_a;
};
class Parent
{
public:
Parent()
{
cout << "Parent的构造函数" << endl;
}
~Parent()
{
cout << "parent的析构函数" << endl;
}
weak_ptr<Child> c;
};
class Child :public Parent
{
public:
Child()
{
cout << "Child的构造函数" << endl;
}
~Child()
{
cout << "Child的析构函数" << endl;
}
weak_ptr<Parent> p;
};
int main(void)
{
#if 0
//weak_ptr<A> wpa(new A(5)); //不能独立操作一块空间
shared_ptr<A> pa(new A(5));
//weak_ptr:类模板，弱指针（弱引用计数）
weak_ptr<A> wpa = pa;
weak_ptr<A> wpb = pa;
weak_ptr<A> wpc = pa; //弱引用不会影响其生命周期，无论多少个弱引用指向这段空间，只要强引用计数为0，则释放这段空间
//常规操作：
shared_ptr<Parent> pp(new Parent);
shared_ptr<Child> cc(new Child);
pp->c = cc;
cc->p = pp;
cout << "hello world" << endl;
shared_ptr<A> pa(new A(5));
//pa.reset();
weak_ptr<A> wpa = pa;
auto pb = wpa.lock(); //将弱指针转为共享指针
if(nullptr == pb)
{
cout << "pb is nullptr" << endl;
}
else
{
cout << "pb is not nullptr" << endl;
}
//wpa.reset(); //弱引用计数-1,
cout << wpa.use_count() << endl; //返回的是weak_ptr的引用计数
cout << pb.use_count() << endl;
if (wpa.expired()) //判断当前弱指针指向的对象是否被释放，弱被释放，返回true,否则返回false
{
cout << "wpa poniter class is free" << endl;
}
shared_ptr<int> p(new int(5));
cout << sizeof(p) << endl;
cout << sizeof(int *) << endl;
weak_ptr<int> wp = p;
cout << sizeof(wp) << endl;
#endif
//局部对象释放两次，A自己释放一次，share_ptr还会释放一次
/*A a;
shared_ptr<A> tmp = a.GetAddr();*/
/*
shared_ptr<A> GetAddr()
{
//return this;
shared_ptr<A> tmp(this);
return tmp;
}
*/
shared_ptr<A> pa(new A());
auto tmp = pa->GetAddr();
cout << pa.use_count() << endl;
cout << tmp.use_count() << endl;
int * pt = new int();
shared_ptr<int> spt1(pt);
shared_ptr<int> spt2(pt);
std::cout << "spt1.use_count() = " << spt1.use_count() << std::endl;
std::cout << "spt2.use_count() = " << spt2.use_count() << std::endl;
return 0;
}
1.4.4 总结
优点:防止内存泄漏 缺点：造成不必要的开销