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

指向堆内存的裸指针就像一把没有刀鞘的利刃，功能强大但又有安全隐患。裸指针封装成类，就如同设计一个刀鞘。封装类可以让其有更多的自定义行为，处于你设想的可控范围内。这种封装的类就称为像指针的类（pointer-like class），一般都包含有一个裸指针，和一系列的成员函数（包括运算符重载）。根据成员函数的不同，这些pointer-like class可以是智能指针，也可以是容器的迭代器。
new与delete需要成对使用，以避免内存泄漏，但当有异常出现时呢？当在函数中返回堆内存指针，需要由调用者释放时，很容易忘记delete 。
【pointer-like class C++｜封装裸指针为像指针的类】考虑一个动态分配值的函数：
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 heredelete 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 = https://www.isolves.com/it/cxkf/yy/C/2019-12-12/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