杂货边角（24）：C++智能指针和垃圾回收

目录：

Sec1 C C98的显式内存管理的不足

Sec2 C11的智能指针

Sec3 垃圾回收机制

Sec1. C / C++98的显式内存管理的不足

内存管理和垃圾回收是高级语言的重要特征，尤其是随着代码抽象程度的加深，C以及C++98将内存管理完全交给程序员的做法一直是让人诟病的地方，即在堆上显式地通过malloc/free或new/delete来管理所需内存。但是是人就一定会犯错，故而也导致内存故障是程序最为常见的bug：

1. 野指针：对象内存释放后，管理指针却忘记置空；

2. 重复释放：尤其是在跨库协作时，职责边界不明晰的情况下，容易出现；

3. 内存泄露：使用了new分配内存，却根本忘记释放内存，导致内存占用率居高不下，直至泄露。

这一问题也在C++11中通过智能指针的特性得以部分解决。

Sec2. C++11的智能指针

#include <iostream>
#include <string>
#include <memory> //提供了shared_ptr、unique_ptr、weak_ptr三种不同类型的智能指针

/***********************************************************
每个智能指针，无论是shared_ptr、unique_ptr、weak_ptr都重载了*运算符，可以通过*up1这样
的方式来访问该智能指针管理的内存，但是智能指针是一个封装后的指针结构体，和普通的指针并不是同类
数据类型
***********************************************************/
using namespace std;

void process(shared_ptr<int> ptr)
{
cout<<"input ptr:"<<*ptr<<endl;
cout<<"in process use_count:"<<ptr.use_count()<<endl;
}

void print_at_delete(int *p)
{
cout<<"deleting..."<<p<<'\t'<<*p<<endl;
delete p;
}

unique_ptr<int> clone(int p)
{
return unique_ptr<int>(new int(p));
}

void process_unique_ptr(unique_ptr<int> up)
{
cout<<"process unique ptr: "<<*up<<endl;
}

int main()
{
/*
shared_ptr采用引用计数的方式管理所指向的对象。当有一个新的shared_ptr指向同一个对象时（复制shared_ptr等），
引用计数加1。当shared_ptr离开作用域时，引用计数减1。当引用计数为0时，释放所管理的内存。

这样做的好处在于解放了程序员手动释放内存的压力。之前，为了处理程序中的异常情况，往往需要将指针手动封装到类中，
通过析构函数来释放动态分配的内存；现在这一过程就可以交给shared_ptr去做了。
*/
cout<<"test shared_ptr base usage:"<<endl;
shared_ptr<string> p1 = make_shared<string>("");
if(p1 && p1->empty())
*p1 = "hello";

auto p2 = make_shared<string>("world");
cout<<*p1<<' '<<*p2<<endl;

cout<<"test shared_ptr use_count:"<<endl;
cout<<"p1 cnt:"<<p1.use_count()<<"\tp2 cnt:"<<p2.use_count()<<endl;

auto p3 = p2;
cout<<"p1 cnt:"<<p1.use_count()<<"\tp2 cnt:"<<p2.use_count()<<"\tp3 cnt:"<<p3.use_count()<<endl;
p2 = p1;
cout<<"p1 cnt:"<<p1.use_count()<<"\tp2 cnt:"<<p2.use_count()<<"\tp3 cnt:"<<p3.use_count()<<endl;

cout<<"test shared_ptr and new:"<<endl;
shared_ptr<int> p4(new int(1024));
//shared_ptr<int> p5 = new int(1024); // wrong, no implicit constructor
cout<<*p4<<endl;

cout<<"\ndon't mix shared_ptr and normal pointer:"<<endl;
shared_ptr<int> p5(new int(1024));
process(p5);
int v5 = *p5;
cout<<"p5 count:"<<p5.use_count()<<endl;
cout<<"v5: "<<v5<<endl;

int *p6 = new int(1024);
cout<<endl<<"p6 ptr_address: "<<p6<<endl;
cout<<"p6 :"<<*(shared_ptr<int>(p6))<<endl; //1024
cout<<"p6 :"<<*(shared_ptr<int>(p6))<<endl; //26, 已经产生了不可逆的破坏，故而切记不能混用普通指针和智能指针，普通指针只能在智能指针初始化的时候可以用
cout<<"p6 count:"<<(shared_ptr<int>(p6)).use_count()<<endl;
cout<<"p6 :"<<*(shared_ptr<int>(p6))<<endl;
cout<<"p6 count:"<<(shared_ptr<int>(p6)).use_count()<<endl;
process(shared_ptr<int>(p6)); //不能混用new和shared_ptr，猜想shard_ptr是个结构体，而new只是raw pointer，显然两者不能等价混用
//即不存在普通int*指针到hared_ptr<int>智能指针的安全的类型转换操作,
//这种直接将int*指针强制转化为shared_ptr<int>操作会导致原先int*指针产生不可逆的破坏，并且会将该指针改装成一个新的数，使其表现
//为process（）函数的临时参数，从而导致函数返回后，p6指针指向的空间已经被释放，从而导致数据对应不上
cout<<"p6:"<<(shared_ptr<int> (p6))<<endl;
int v6 = *p6;
cout<<"v6: "<<v6<<endl;

cout<<"\ntest shared_ptr reset:"<<endl;
cout<<"p1 cnt:"<<p1.use_count()<<"\tp2 cnt:"<<p2.use_count()<<"\tp3 nt:"<<p3.use_count()<<endl;
p1.reset(new string("cpp11"));
cout<<"p1 cnt:"<<p1.use_count()<<"\tp2 cnt:"<<p2.use_count()<<"\tp3 cnt:"<<p3.use_count()<<endl;

cout<<"\ntest shared_ptr deleter注册自定义的析构函数:"<<endl;
int *p7 = new int(1024);
shared_ptr<int> p8(p7, print_at_delete); //初始化同时，并注册析构函数
cout<<*p8<<endl;
p8 = make_shared<int>(1025);
cout<<*p8<<endl;

/*unique_ptr对于所指向的对象，正如其名字所示，是独占的。所以，不可以对unique_ptr进行拷贝、赋值等操作，
但是可以通过release函数以及move函数在unique_ptr之间转移所有权。
所以从实现的角度来看：unique_ptr是一个删除了拷贝构造函数（=delete或者private化）、保留了移动构造函数的指针封装类
*/
cout<<"\ntest unique_ptr base usage测试unique_ptr使用方式:"<<endl;
unique_ptr<int> up1(new int(1024));
cout<<"up1: "<<*up1<<endl;
unique_ptr<int> up2(up1.release()); //up1调用release后则将内容传递给up2，并且自身置为空指针
cout<<"up2: "<<*up2<<endl;
//cout<<"up1: "<<*up1<<endl; //此时up1已经是空指针了
//unique_ptr<int> up3(up1); // wrong, unique_ptr can not copy
//up2 = up1; // wrong, unique_ptr can not copy
unique_ptr<int> up4(new int(1025));
up4.reset(up2.release());
cout<<"up4: "<<*up4<<endl;

cout<<"\ntest unique_ptr parameter and return value:"<<endl;
auto up5 = clone(1024);
cout<<"up5: "<<*up5<<endl;
process_unique_ptr(move(up5));
//process_unique_ptr(up5); //unique_ptr是不能copy，以及赋值的，哪怕是形参传递，也是应该显式释放内容的
// move(up5)之后，up5智能指针其实已经被释放了，故而后续再访问，将会导致内存问题
//cout<<"up5 after process: "<<*up5<<endl; // would cause segmentfault

/*
unique_ptr同样可以设置deleter，和shared_ptr不同的是，它需要在模板参数中指定deleter的类型。
好在我们有decltype这个利器，不然写起来好麻烦。
*/
cout<<"\ntest unique_ptr deleter专属智能指针注册析构函数:"<<endl;
int *p9 = new int(1024);
unique_ptr<int, decltype(print_at_delete) *> up6(p9, print_at_delete);
cout<<"up6..."<<*up6<<endl;
unique_ptr<int> up7(new int(1025));
cout<<"up7..."<<*up7<<endl;
up6.reset(up7.release()); //up7.release()单独使用是不会触发定制析构函数的，
//但是如果采用这种形参方式传递给注册了析构函数的up6则会连带着一起触发析构
unique_ptr<int> up8(new int(1010));
up8.release();
//这种单独release()的形式便不会触发调用定制的析构函数

/*
weak_ptr一般和shared_ptr配合使用。它可以指向shared_ptr所指向的对象，但是却不拥有该对象的所有权，即不增加对象的引用计数。
这样就有可能出现weak_ptr所指向的对象实际上已经被释放了的情况。
因此，weak_ptr有一个lock函数，尝试取回一个指向对象的shared_ptr，并在shared_ptr无效时，返回nullptr。
*/
cout<<"\ntest weak_ptr basic usage不占引用计数的weak_ptr智能指针使用:"<<endl;
auto p10 = make_shared<int>(1024);
weak_ptr<int> wp1(p10);
cout<<"p10 use_count: "<<p10.use_count()<<endl;
//p10.reset(new int(1025)); // this will cause wp1.lock() return a false obj
shared_ptr<int> p11 = wp1.lock();
if(p11)
cout<<"wp1: "<<*p11<<" use count: "<<p11.use_count()<<endl;

return 0;
}

OUTPUT

Sec3. 垃圾回收机制

垃圾回收机制中主要是：基于引用计数的回收和基于使用跟踪的中断式遍历回收。这篇文章关于垃圾回收有着清晰的讲究。

C++11关于垃圾回收的支持力度其实还是不够大的，像JVM和CLR都是采用分代式垃圾回收机制（混合机制）来进行垃圾回收，而C++最大的魅力来源之一也是其指针的灵活性，既然为了保留指针使用的灵活性盲目地上垃圾回收其实短时间内还是不现实的，但是C++11提出了最小垃圾回收机制的支持。不过从现在开始使用智能指针确实可以避免很多raw pointer使用问题的出现了，至于专业的内存优化和垃圾回收也是有专业的库和工具可以使用的。