智能指针

shared_ptr 和 unique_ptr

/*
	头文件: <memory> //shared_ptr unique_ptr make_shared....
	智能指针: 当计数器到达0时, 自动释放指针所占内存, 分为两种
	1. shared_ptr: 允许多个指针指向同一个对象, 若加入一个指针指向那么计数器++,若减少一个计数器--, 当计数器到达0时, 会自动释放指针所占内存空间
		make_shared<T>(args): 指向一个动态分配类型为T的对象, 使用args初始化此对象
		shared_ptr<T>p(q): p是q的拷贝, 此操作会增加q中的计数器, 且q能转换成T类型
		p.use_count(): 返回p所共享智能指针的数量, 速度很慢, 主要用于调试
		p.unique(), 若共享数量为1则表示独占,返回true 否则false
		
	2. unique_ptr: 独占所指向的对象
	3. week_ptr: 伴随类, 弱引用, 指向shared_ptr所管理的对象
*/

动态内存分配

/*
	1. 申请内存异常处理 
	头文件 <new>//bad_alloc 和 nothrow
	若申请内存空间失败, 那么系统会抛出异常: bad_alloc, 我们可以采用new的方式阻止异常的抛出
    int *p1 = new int; //若内存耗尽, 抛出bad_alloc
    int *p2 = new (nothrow) int; //如果分配失败, new返回一个空指针
    //可以后续判断p2是否为null
    
    2. 动态分配的const对象
    可以通过new分配const对象
    const int *p1 = new const int(1024);//分配并初始化
    
    3. 如果new 分配的内存空间通过delete释放以后, 如果不让他指向nullptr,那么他还是可以调用已经释放的数据, 也就是C++文件夹里面所讲的恐怖的野指针, 也叫 空悬指针, 即 指向一块曾经保存数据对象但现在已经无效的内存的指针
    正确的做法:
    		delete p;
    		p = nullptr;
    		
    4. 可以使用new来初始化shared_ptr
    	shared_ptr<int> p(new int(2))
*/
#include <iostream>
#include <new>
#include <memory>
#include <vector>

using namespace std;

typedef shared_ptr<vector<int>> sh_vec_int;
sh_vec_int createVector()
{
    sh_vec_int *vec = make_shared<vector<int>>();
    cout<<"createVector shared_ptr:"<< vec.use_count()<<endl;
    return vec;
}
//如果输入输出不加引用那么就会多产生一个中间副本的sh_vec_int指向同一个地址, 造成了资源浪费
void cinVector(istream &is,sh_vec_int &vec)
{
    /*
    	输入
    */
    cout<<"cinVector shared_ptr:"<< vec.use_count()<<endl;//cinVector shared_ptr:1
}
void coutVector(ostream &os,sh_vec_int &vec)
{
    /*
    	输出
    */
    cout<<"coutVector shared_ptr:"<< vec.use_count()<<endl;//coutVector shared_ptr:1
}

int main()
{
    sh_vec_int vec = createVector();
    cout<<"main() shared_ptr:"<< vec.use_count()<<endl;//输出main() shared_ptr: 1
    cinVector(cin,vec);
    coutVector(cout,vec);
    return 0;
}

智能指针和异常

void f()
{
    int *i = new int(7);
    //code:抛出异常
    delete i;
}

void f()
{
    auto i = make_shared<int>(7);
    //code: 抛出异常    
}

//两种区别是第一种抛出异常的时候内存占用资源不会释放
//第二种抛出异常的时候内存占用的资源自动释放, 因为函数结束, 计数器清零, 此时自动释放所占资源

智能指针:使用自定释放操作

/*
	当有些资源需要手动释放的时候可以通过智能指针来做管理, 以免手动忘记释放
*/
#include <iostream>
#include <memory>

using namespace std;

void end_function(int *i)
{
    /*code*/
}

int main()
{
    {
    	int i = 6;
    	shared_ptr<int> p(&i,end_function);
        //或者采用lambda表达式
        shared_ptr<int> q(&i,
                          [](int* i){
                              /*code*/
                          });
    }
    return 0;
}
//程序块结束后自动调用end_function