C++新特性 引用计数

/*
智能指针

	问题：
	C++中最令人头疼的问题就是强迫程序员对申请的资源进行管理，容易内存泄漏
	C++需要自己管理堆内存的申请和释放
	int * p= new int;
	解决思路：
	利用C++中一个对象出了其作用域会被自动析构，因此我们只需要在构造函数的
	时候申请空间，而在析构函数的时候释放空间，这样就减轻程序员在编码过中，考虑资源释放的问题了RAII
	std::shared_ptr 强指针
	std::unique_ptr 
	std::weak_ptr 弱指针

	引用计数
	深拷贝、浅拷贝
	深拷贝(完全复制)：
	优点：每一个对象的指针都有指向内存的空间，而不是共享，所以对象在析构时候不存在重复释放或者内存泄漏
	缺点：内存开销大
	浅拷贝（类似引用，默认浅拷贝）
	优点：通过拷贝构造函数实例化的对象的指针数据变量指向的共享的内存空间，因此内存开销小
	缺点：对象析构的时候可能重复释放
	智能指针结合了浅拷贝和深拷贝的优缺点
*/

class test
{
public:
	test()
	{
		//在构造的时候完成内容的初始化

		m = new int;
	}
	~test()
	{
		if (m != nullptr)
		{
			//在析构完成资源的释放
			delete m;
		}
	}
private:
	int * m;
};  //减轻资源管理的难度
test t;

void * alloc_data()
{
	int *p = new int;
	return p;
}
FILE* open_file(char* name)
{
	FILE* fp = NULL;
	fp = fopen(name,"rb+");
	return fp;
}

class student
{
public:
	student(const char* pszName);
	student(student& obj);
	~student();
	student& operator=(student & obj);
	void release();
	void Show()
	{
		if (*m_pszName)
		{
			std::cout  << (int &)m_pszName << m_pszName << std::endl;
		}
	}
private:
	char* m_pszName;
	int * m_pCount; //资源计数器当资源为0是，可以被释放
};
student::student(student& obj)
{
	m_pszName = obj.m_pszName;
	m_pCount = obj.m_pCount;
	(*m_pCount)++;
}

student::~student()
{ 
	release();
}
student& student::operator=(student & obj)
{
	if (obj.m_pszName == m_pszName)
	{
		return *this;
	}
	if (--(*m_pCount) == 0)
	{
		delete m_pszName;
		m_pszName = NULL;
		delete m_pCount;

	}
	m_pszName = obj.m_pszName;
	m_pCount = obj.m_pCount;
	(*m_pCount)++;
	return *this;
}
void student::release()
{
	if (m_pszName != NULL&& --*m_pCount == 0)
	{
		//通过资源的重复释放
		delete m_pszName;
		m_pszName = NULL;
		delete m_pCount;
	}
}
	
int main()
{
	//通过了new在堆上分配了4给字节的空间
	//C++需要自己管理内存的申请和释放
	alloc_data();
	//按道理在函数外部堆堆资源进行释放

	//忘记资源释放
	//java 使用虚拟机垃圾回收释放，不需要人为管理
}