C++｜封装裸指针为像指针的类（pointer-like class）

指向堆内存的裸指针就像一把没有刀鞘的利刃，功能强大但又有安全隐患。裸指针封装成类，就如同设计一个刀鞘。封装类可以让其有更多的自定义行为，处于你设想的可控范围内。这种封装的类就称为像指针的类（pointer-like class），一般都包含有一个裸指针，和一系列的成员函数（包括运算符重载）。根据成员函数的不同，这些pointer-like class可以是智能指针，也可以是容器的迭代器。

new与delete需要成对使用，以避免内存泄漏，但当有异常出现时呢？当在函数中返回堆内存指针，需要由调用者释放时，很容易忘记delete。

考虑一个动态分配值的函数：

void someFunction(){ Resource *ptr = new Resource; // Resource is a struct or class // do stuff with ptr here delete ptr;}

尽管上面的代码看起来相当简单，但是很容易忘记释放ptr。即使您确实记得在函数的末尾删除PTR，但是如果函数早退出，就有无数种方法可以不删除PTR。这可以通过提前返回来实现或者通过抛出异常：

#include <IOStream>
 
void someFunction()
{
 Resource *ptr = new Resource;
 
 int x;
 std::cout << "Enter an integer: ";
 std::cin >> x;
 
 if (x == 0)
 throw 0; // the function returns early, and ptr won’t be deleted!
 
 // do stuff with ptr here
 
 delete ptr;
}

在上述程序中，执行早期的return或throw语句，导致函数终止而不删除变量ptr。因此，分配给变量ptr的内存现在泄漏了（每次调用此函数并提前返回时，都会再次泄漏）。

从本质上讲，这些问题的发生是因为指针变量本身没有内在的机制来清理它们。

当函数返回指向堆内存的指针给调用者时：

Gadget* f(int n)
{
 // ... 
 auto p = new Gadget{n};
 return p;
}
void foo(n)
{
 auto p = f(n);
 // ……
 delete p; // easily forgot
}

上面的程序如果调用函数没有忘记，可以完成堆内存释放，但违背了“谁申请，谁释放”的原则，不是最佳的模块设计。

我们知道，局部变量（存储在栈上）在超出作用域时会自动释放。而类对象的机制增加了一个自动析构的析构函数，即局部对象（存储在栈上）不但自动释放内存，而且还自动执行一个析构函数，通常，我们会在析构函数中定义释放堆内存的行为。如果一个裸指针指向堆内存，就存在一个需要释放堆内存的行为，如果将此裸指针封装，释放的动作放在析构函数内，那此释放的动作就会自动化了，这就是裸指针封装的原因：

template<typename T>
class SP
{
public:
	SP():p(NULL){}
	SP(int n){p = new char[n];}
	~SP(){ delete[] p;}
	T& operator*() const
	{ return *px; }
	T* operator->() const
	{ return px; }
	SP(T* p):px(p){}
	// 如果用做迭代器要重载++、--、+n、-n等运算符
private:
	T* px;
	long* pn;
};

另外，当多个指针指向同一块堆内存时，怎样delete？如何避免出错？如指针的复制、移动行为，指针形参与指针实参结合时：

void passByValue(Auto_ptr1<Resource> res)
{
}
 
int main()
{
	Auto_ptr1<Resource> res1(new Resource);
	passByValue(res1)
 
	return 0;
}

在这个程序中，res1将被value复制到passByValue的参数res中，从而导致资源指针的复制。多个指针指向同一块堆内存，一个指针的delete行为势必影响到另一个指针。

很明显这不好。我们如何解决这个问题？

移动语义或unique_ptr或shared_ptr。

对于文件句柄，同样的，封装的文件流对象具有更好的安全性：

 void f(const string& name)
{
 FILE* f = fopen(name, "r"); // open the file
 vector<char> buf(1024);
 auto _ = finally([f] { fclose(f); }); // remember to close the file
 // ...
}

以上实例，buf的内存分配可能失败，然后文件句柄产生泄露。

以下实例使用则用封装的文件流对象，则可最大限度避免：

于void f(const string& name)
{
 ifstream f{name}; // open the file
 vector<char> buf(1024);
 // ...
}

同样的，也可以将指向堆内存的裸指针封装为一个迭代器，让其能够方便、安全地操作容器元素：

要自定义一个迭代器，就要重载一些基本操作符：*（解引用）、++（自增）、==（等于）、!=（不等于）、=（赋值）等。

#include <iostream>
using namespace std;
template <typename T>
class linkedList
{
private:
	struct node
	{
		int data;
		node * next;
	};
	typedef node* NODEPTR;
	
public:
	NODEPTR head;
	linkedList():head(NULL){}
	linkedList& push_front(int e)
	{
		NODEPTR p = new node;
		p->data = e;
		p->next = NULL;
		if(head!=NULL)
			p->next = head;
		head = p;
		return *this;
	}
	typedef NODEPTR _range;
	class iterator
	{
	private:
		_range p;
	public:
		iterator():p(NULL){}
		iterator(const linkedList& ll):p(ll.head){}
		iterator & operator+(const iterator& itr)
		{
			p=itr.p;
			return *this;
		}
		iterator& operator++()
		{
			p = p->next;
			return *this;
		}
		bool operator != (const iterator& itr)
		{
			return p!= itr.p;
		}
		T& operator *()
		{
			return p->data;
		}
	};
	iterator begin()
	{
		return iterator(*this);
	}
	iterator end()
	{
		return iterator();
	}
};
int main()
{ 
	linkedList<int> list;
	for(int i=0;i<=5;i++)
		list.push_front(i);
	
	for(linkedList<int>::iterator itr = list.begin();
			itr!=list.end();++itr)
		cout<<*itr<<' ';
	cin.get();
 return 0;
}
// 5 4 3 2 1 0