智能指针原理理解 和 ->运算符的重载

一个内存泄漏的实例：

#include<iostream>

void Func(int *p)
{
	int *ptmp = new int;
	if (p == NULL)
	{
		throw std::exception("p is null!");
	}
	*ptmp = *p;
	delete ptmp;
}

int main()
{
	while (true)
	{
		try{
			Func(NULL);
		}
		catch (std::exception& error)
		{
			std::cout << error.what() << std::endl;
		}
	}
	return 0;
}

        我们给Func函数的实参传入了一个NULL，当进入到Func函数内的 if 判断时，抛出异常，返回函数的调用点，但是Func函数没有释放 ptmp 所指向的内存，导致了内存泄露，这种问题一般是很难处理的，因此有了智能指针来帮助我们解决这个问题。

对智能指针的分析：

代码如下：

#include<iostream>

class SmartPtr
{
public:
	SmartPtr(int *p) :ptr(p){}
	SmartPtr()
	{
		delete ptr;
		ptr = NULL;
	}
private:
	int *ptr;
};

int main()
{
	int *p = new int;
	delete p;

	SmartPtr sp = new int; //相比上一行，不用手动释放，由对象sp的析构函数来完成释放这个操作
	return 0;
}

->运算符的重载（->是单目运算符）：

->运算符三步：  

        <1>       sp.operator->()   //对象先调用 operator->() 函数

        <2>       Test*   ptmp    //由第一步得到

        <3>       ptmp->Show()  //通过指针来调用函数

#include<iostream>
using namespace std;

class Test
{
public:
	Test(int val) :data(val){}
	
	void Show()
	{
		std::cout << data << std::endl;
	}
private:
	int data;
};

class SmartPtr 
{
public:
	SmartPtr(Test *p)
	{
		ptr = p;
	}
	~SmartPtr()
	{
		delete ptr;
	}
	Test& operator*()
	{
		return *ptr;
	}
	Test* operator->() 
	{
		return ptr;
	}
private:
	Test *ptr;
};

int main()
{
	
	Test *p = new Test(10);
	p->Show(); //通过指针就可以释放空间
	delete p;

	SmartPtr sp = new Test(20);
	sp->Show(); //重载运算符->后, 则变为ptmp->Show()，ptmp为Test* 类型
	return 0;
}