内存泄露 智能指针

内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。

内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。

memory leak会最终会导致out of memory！

内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是产生溢出。

内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。一个盘子用尽各种方法只能装4个果子，你装了5个，结果掉倒地上不能吃了。这就是溢出！比方说栈，栈满时再做进栈必定产生空间溢出，叫上溢，栈空时再做退栈也产生空间溢出，称为下溢。就是分配的内存不足以放下数据项序列,称为内存溢出.

以发生的方式来分类，内存泄漏可以分为4类：

1. 常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。 
2. 偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。 
3. 一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。比如，在类的构造函数中分配内存，在析构函数中却没有释放该内存，所以内存泄漏只会发生一次。 
4. 隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，我们称这类内存泄漏为隐式内存泄漏。 

从用户使用程序的角度来看，内存泄漏本身不会产生什么危害，作为一般的用户，根本感觉不到内存泄漏的存在。真正有危害的是内存泄漏的堆积，这会最终消耗尽系统所有的内存。从这个角度来说，一次性内存泄漏并没有什么危害，因为它不会堆积，而隐式内存泄漏危害性则非常大，因为较之于常发性和偶发性内存泄漏它更难被检测到

内存泄漏：

原因：
在内存中供用户使用的内存区有三个：
程序存储区、
静态存储区、
动态存储区。

程序的数据一般存放在静态存储区和动态存储区。

静态存储区是当程序开始的时候就分配好的一块固定的内存区。

动态存储区一般是在程序运行过程中根据需要动态去分配和释放的内存区域。这块内存区域需要开发人员在使用完毕之后进行释放，如果没有释放动态分配的内存区域就会造成内存泄漏。相应的这块区域也不能够被使用。

简单来说，就是你使用了一块内存区域，但是却没有释放，那么这块内存区域谁都用不了了，这就是内存泄漏。

内存碎片:

内存碎片分为外部碎片和内部碎片

外部碎片：

外部碎片指的是还没有被分配出去（不属于任何进程），但由于太小了无法分配给申请内存空间的新进程的内存空闲区域。

原因：

外部碎片是出于任何已分配区域或页面外部的空闲存储块。这些存储块的总和可以满足当前申请的长度要求，但是由于它们的地址不连续或其他原因，使得系统无法满足当前申请。

内部碎片：

内部碎片就是已经被分配出去（能明确指出属于哪个进程）却不能被利用的空间；

原因：

内部碎片是处于内部或页面内部的存储块。占有这些区域或页面的进程并不使用这个存储块。而在进程占有这块存储块时，系统无法利用它。直到进程释放它，或进程结束时，系统才有可能利用这个存储块。

为什么要使用智能指针：

智能指针的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束时忘记释放，造成内存泄漏。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。

RAII:

//RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源
//（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
//在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，
//最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。

这种做法有两大好处：

1.不需要显式地释放资源。
2.采用这种方式，对象所需的资源在其生命期内始终保持有效。

// 使用RAII思想设计的SmartPtr类
#include <iostream>
using namespace std;
template<class T>
class Smartptr
{
public:
	Smartptr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~Smartptr()
	{
		if (_ptr)
			delete _ptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};

struct Date
{
	int _year = 2019;
	int _month = 8;
	int _day = 11;
};

int main()
{
	Smartptr<int> sp1(new int);
	*sp1 = 10;
	cout << *sp1 << endl;

	Smartptr<Date> sparray(new Date);
	cout << sparray->_year << '-';
	cout << sparray->_month << '-';
	cout << sparray->_day << endl;
	return 0;
}

C++98版本的库中就提供了auto_ptr的智能指针。

// 模拟实现一份简答的AutoPtr,了解原理
template<class T>
class AutoPtr
{
public:
	AutoPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~AutoPtr()
	{
		if (_ptr)
			delete _ptr;
	}
	// 一旦发生拷贝，就将ap中资源转移到当前对象中，然后另ap与其所管理资源断开联系，
	// 这样就解决了一块空间被多个对象使用而造成程序奔溃问题
	AutoPtr(AutoPtr<T>& ap)
		: _ptr(ap._ptr)
	{
		ap._ptr = nullptr;
	}
	AutoPtr<T>& operator=(AutoPtr<T>& ap)
	{
		// 检测是否为自己给自己赋值
		if (this != &ap)
		{
			// 释放当前对象中资源
			if (_ptr)
				delete _ptr;
			// 转移ap中资源到当前对象中
			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}
		return *this;
	}
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
private:
	T* _ptr;
};
struct Date
{
	int _year = 2019;
	int _month = 8;
	int _day = 11;
};
int main()
{
	AutoPtr<Date> ap(new Date);
	// 现在再从实现原理层来分析会发现，这里拷贝后把ap对象的指针赋空了，导致ap对象悬空
	// 通过ap对象访问资源时就会出现问题。
	AutoPtr<Date> copy(ap);
	//ap->_year = 2018;                       //autoptr智能指针以弃用,缺点  浅拷贝问题未解决,拷贝后访问原始资源会出现问题
	return 0;
}

C++11中开始提供更靠谱的unique_ptr:

//模拟实现Unique_ptr,了解原理
template<class T>
class UniquePtr
{
public:
	UniquePtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~UniquePtr()
	{
		if (_ptr)
			delete _ptr;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

	//C++11防拷贝方式:delete
	UniquePtr(UniquePtr<T> const&) = delete;
	UniquePtr & operator=(UniquePtr<T> const&) = delete;

private:
	//C++98防拷贝方式:只声明不实现+声明成为私有
	//UniquePtr(UniquePtr<T> const&);
	//UniquePtr & operator=(UniquePtr<T> const&);
	

private:
	T* _ptr;
};

struct Date
{
	int _year = 2019;
	int _month = 8;
	int _day = 11;
};

int main()
{
	UniquePtr<Date> ap(new Date);
	
	//UniquePtr<Date> copy(ap);//简单粗暴的防拷贝
	return 0;
}

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr:

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

缺点:

1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或--，这
个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。会导致资源未
释放或者程序崩溃的问题。所以只能指针中引用计数++、--是需要加锁的，也就是说引用计数的操作是
线程安全的。
2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

//模拟实现SharedPtr,了解原理
#include <iostream>
#include <thread>
#include <mutex>//涉及线程安全问题

using namespace std;  


//定置删除器

//new
template<class T>
class DFDel
{
public:
	void operator() (T*& p)
	{
		if (p)
		{
			delete p;
			p = nullptr;
		}
	}

};
//malloc
template<class T>
class Free
{
public:
	void operator() (T*& p)
	{
		if (p)
		{
			free(p);
			p = nullptr;
		}
	}

};
//FILE*
class FClose
{
public:
	void operator() (FILE*& pf)
	{
		if (pf)
		{
			fclose(pf);
			pf = nullptr;
		}
	}

};

template<class T,class DF = DFDel<T>>
class SharedPtr
{
public:
	SharedPtr(T* ptr = nullptr)
		:_pRefCount(new int(1))
		,_ptr(ptr)
		,_pMutex(new mutex)
	{}
	~SharedPtr()
	{
		Release();
	}

	SharedPtr(const SharedPtr<T>& sp)
		:_ptr(sp._ptr)
		, _pRefCount(sp._pRefCount)
		, _pMutex(sp._pMutex)
	{
		AddRefCount();
	}

	SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		if (_ptr != sp._ptr)
		{
			Release();

			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			_pMutex = sp._pMutex;

			AddRefCount();
		}
		return *this;
	}

	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}

	int UseCount()
	{
		return *_pRefCount;
	}
	T* Get()
	{
		return _ptr;
	}

	void AddRefCount()
	{
		//加锁或者使用+1原子操作
		_pMutex->lock();
		++(*_pRefCount);
		_pMutex->unlock();
	}
private:
	void Release()
	{
		bool deleteflag = false;
		//引用计数减1，如果减到0，则释放资源
		//保证原子操作
		_pMutex->lock();
		if (--(*_pRefCount) == 0 && _ptr)
		{
			//DF df;
											//df.operator() (_ptr);
			//df(_ptr);																			
			DF() (_ptr);
					    					//delete _ptr;
			delete _pRefCount;
			deleteflag = true;
		}
		_pMutex->unlock();

		if (deleteflag == true)
			delete _pMutex;
	}
private:
	int * _pRefCount; //引用计数
	T* _ptr;//指向管理资源的指针
	mutex* _pMutex;      //互斥


};

void TestSharedPtr()
{
	SharedPtr<int> sp1(new int);
	SharedPtr<int, Free<int>> sp2((int*)malloc(sizeof(int)));
	SharedPtr<FILE,FClose> sp3(fopen("0.0.txt", "w"));
}

int main()
{
	///*sharedptr<int> sp1(new int(10));
	//sharedptr<int> sp2(sp1);
	//*sp2 = 20;
	//cout << sp1.usecount() << endl;
	//cout << sp2.usecount() << endl;
	//
	//sharedptr<int> sp3(new int(10));
	//sp2 = sp3;
	//cout << sp1.usecount() << endl;
	//cout << sp2.usecount() << endl;
	//cout << sp3.usecount() << endl;

	//sp1 = sp3;
	//cout << sp1.usecount() << endl;
	//cout << sp2.usecount() << endl;
	//cout << sp3.usecount() << endl;*/


	TestSharedPtr();

	return 0;
}

关于循环引用:

//采用循环双向链表的方式------循环引用                     未销毁引用计数出问题   未调用析构函数
#include <iostream>
#include <memory>
using namespace std;
struct  ListNode
{
	ListNode(int data)
		//:next(nullptr)
		//, prev(nullptr)
		//, _data(data)
		:_data(data)
	{
		cout << "ListNode(int):" << this << endl;
	}
	~ListNode()
	{
				cout << "~ListNode():" << this << endl;
	}
	//ListNode* _pNext;
	//ListNode* _pPre;


	//存在循环引用
	//shared_ptr<ListNode> next;
	//shared_ptr<ListNode> prev;

	//使用weak_ptr解决循环引用
	weak_ptr<ListNode> next;                //不接受参数   屏蔽初始化位置           
	weak_ptr<ListNode> prev;
	int _data;
};


//C++11中引入weak_ptr作用:专门解决shared_ptr中存在的循环引用问题
		//weak_ptr不能单独管理资源--->配合shared_ptr一块使用

void TestSharedPtr()
{
	shared_ptr<ListNode> sp1(new ListNode(10));
	shared_ptr<ListNode> sp2(new ListNode(20));

	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;

	sp1->next = sp2;
	sp2->prev = sp1;

	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
}


int main()
{
		//weak_ptr<int> wp(new int);      不能独立拥有资源
	TestSharedPtr();
	return 0;
}

C++11和boost中智能指针的关系

1. C++ 98 中产生了第一个智能指针auto_ptr.
2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的
   scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。