C++primer第十二章读书笔记---动态内存与智能指针

Posted 2020-07-02

    目前为止我们使用过的静态内存，栈内存和内存池，静态内存用来保存局部static对象、类static成员，以及定义在任何函数之外的成员。栈内存用来保存定义在函数内部的非static成员，分配在静态 内存或栈内存中的对象由编译器自动创建或销毁，对于栈对象仅在其定义的程序块运行时才有效，static对象在程序运行之前分配，程序结束时销毁。除了静态内存和栈内存外，每个程序还拥有一个内存池（堆）在堆上分配动态对象，当动态对象不再使用时，我们必须显示的销毁它。
    （一）、动态内存与智能指针
    new在动态内存中为对象开辟空间，并返回指向该对象的指针；delete接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。
    动态内存的使用很容易出现问题，有时候我们会忘记释放它，在这种情况下就会造成内存泄露，泄露的内存越堆积越多最终编译器无法为程序分配新的内存，系统崩溃。有时在尚有指针引用的内存的情况下我们就释放它，这种情况下会产生引用非法内存的指针。
    说了这么多，让人感觉动态内存挺矫情的，不过矫情有矫情的治法，在这种情况下智能指针就能够很好地解决这种状况。智能指针行为类似常规指针，最最重要的区别就是它是一个负责任的指针，能够中自动释放所指向的对象。
    （1）sharedptr--允许多个指针指向同一个对象
    （2）scopedptr--守卫智能指针，简单粗暴
    智能指针也是模板，因此当我们创建一个智能指针时必须提供额外的信息---智能指针指向的类型
    在尖括号内给出类型，之后就是定义这种智能指针的名字：
    sharedptr<string> p1   //sharedptr,可以指向string
    sharedptr<list<int>> p2 //sharedptr,可以指向int的List链表
    默认初始化的智能指针中保存着一个空指针，智能指针的使用方式与普通指针类似，解引用一个智能指针返回指向它的对象，如果在一个条件判断中使用智能指针，效果就是检测它是否为空。
    （二）sharedptr自动销毁所管理的对象
    当指向对象的最后一个sharedptr 被销毁时，sharedptr会自动销毁此对象，它通过析构函数完成销毁工作，析构函数一般用来释放对象所分配的资源。除此之外，sharedptr 还会自动释放相关联的内存。它是通过引用计数的方式来管理内存的，
    shardptr<T>P(q)  
    p是sharedptr的拷贝，此操作会递增q中的引用计数，q中的指针必须转化为T*
    p=q
    p和q都是sharedptr,所保存的指针必须能够相互转化，此操作会递减p的引用计数，递增q的引用计数；若p的引用计数变为0，则将其管理的原来内存释放；
    
    有关这两个指针的实现具体看后边的源代码哦
#include<iostream>
using namespace std;
template<typename T>
//1
class Autoptr
{
public:
	//构造函数
	Autoptr(T* ptr):_ptr(ptr)
	{}
	//析构函数
    ~Autoptr()
	{
		if(_ptr)
		{
			cout<<"delete"<<_ptr<<endl;
			delete _ptr;
			_ptr=NULL;
		}
	}
	//拷贝构造函数
	Autoptr(Autoptr<T> &ap):_ptr(ap._ptr)
	{
	ap._ptr=NULL;
	}
	//赋值运算符符重载
	Autoptr<T>& operator=(Autoptr<T> &ap)
	{
		if(this!=&ap)
		{
		delete _ptr;
		_ptr=ap._ptr;
		ap._ptr=NULL;
		}
	return *this;
	}
	//->运算符重载
	T* operator->()
	{
	return _ptr;
	}
	//*运算符重载
	T&operator*()
	{
	return *_ptr;
	}
private:
	T* _ptr;
};

//
template <typename T>
class Scopedptr
{
public:
//
Scopedptr(T* ptr):_ptr(ptr)
{}
//
~Scopedptr()
{
	if(_ptr)
	{
	cout<<"delete"<<_ptr<<endl;
	delete _ptr;
	}

}
//->运算符重载
	T* operator->()
	{
	return _ptr;
	}
	//*运算符重载
	T&operator*()
	{
	return *_ptr;
	}
//防拷贝
//只声明不实现
//	（1）声明为保护或私有成员防止函数在外边被篡改
//	（2）防止调用默认的函数
protected:
Scopedptr(Scopedptr<T> &sp);
Scopedptr<T>&operator=(Scopedptr<T>& sp);
protected:
	T *_ptr;
};

template <typename T>
class Shardptr
{
public:
	//构造函数
	Shardptr(T *ptr)
		:_ptr(ptr)
		,_pcount(new long(1))
	{
	
	}
	//析构函数
	~Shardptr()
	{
		if(--(*_pcount)==0)
		{
		delete _ptr;
		delete _pcount;
		}
	}
	//拷贝构造函数
	Shardptr(Shardptr<T>& sp)
		:_ptr(sp._ptr)
		,_pcount(sp._pcount)
	{
	   ++(*_pcount);
	}
	//赋值运算符重载
	Shardptr<T>& operator=(const Shardptr<T>& sp)
	{
	//sp1=sp1
	//sp1=sp2
	//sp1=sp3
		if(this_ptr!=sp._ptr)
		{
		if(--(*_pcount)==0)
		{
		delete _ptr;
		delete _pcount;
		}
		_ptr=sp._ptr;
		_pcount=sp._count;
		++(*_pcount);
		}
	}
	//
	T& operator*()
	{
	return *_ptr;
	}
	//
	T* operator->()
	{
	return _ptr;
	}
	//
	long Usecount()
	{
	return *_pcount;
	}
private:
	T*_ptr;
	long*_pcount;
};

//
template<typename>
class ScopedArray
{
pubilc:
	ScopedArray(T* ptr):_ptr(ptr)
	{}
   ~ScopedArray()
	{
		if(_ptr)
		{
		delete [] _ptr;
		}
	}
   //
   T& oprator[](size_t index)
   {
    return _ptr[index];
   }
protected:
	ScopedArray(const ScopedArray<T>&sp);
	ScopedArray(const ScoopedArray<T>&sp);
private:
	T * _ptr;
};
void test1()
{
//int *p=new int(1);
//Autoptr<int>ap(p);
	Autoptr<int>ap1(new int(1));
	Autoptr<int>ap2(ap1);
	Autoptr<int>ap3(new int(2));
	ap3=ap2;
	*ap3=10;//ap3.operator*(&ap3);
	/*Autoptr<int>ap4(new A);
	ap4->_a=10;*/
	cout<<ap3.operator*()<<endl;
}
void test2()
{
 //Scopedptr<int>sp1(new int(2));
}


void TestShardptr()
{
	Shardptr<int> sp1(new int(1));
	Shardptr<int>sp2(sp1);
	*sp2=20;
	Shardptr<int>sp3(new int(3));
	/*sp3=sp2;*/
	cout<<"sp:"<<sp1.Usecount()<<endl;
	cout<<"sp2:"<<*sp2<<endl;
}
void TestScopedArray()
{
ScopedArray<A> sa(new A[10]);

}
int main()
{
TestShardptr();
system("pause");
return 0;
}