指向堆的裸指针就像一把没有刀鞘的利刃，功能强大但又有安全隐患。裸指针封装成类，就如同一个刀鞘。封装类可以让其有更多的自定义行为，处于你设想的可控范围内。这种封装的类就称为像指针的类（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 <tream>
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
胜象大百科
