RAII（Resource Acquisition Is Initialization：资源获取即初始化）

1.裸指针，操作不当导致，空悬指针（指针所指向的资源已经被释放，但是指针未置空），内存泄漏，重复释放

2.栈展开的过程中不会自动释放

3.应用RAII技巧，将裸指针换为智能指针（是一个类），将指针转为对象，对象的析构函数在生命周期结束的时候是确定被调用的

4.RAII（Resource Acquisition Is Initialization：资源获取即初始化）。一个对象可拥有资源。在对象的构造函数中执行资源的获取（指针的初始化），在析构函数中释放。

5.资源：内存，文件句柄，套接字，互斥量

NodePtr.h

#ifndef _NODEPTR_H_
#define _NODEPTR_H_

class Node {
public:
Node() {
std::cout << "Node()"<< std::endl;
}
virtual ~Node() {
std::cout << "~Node()"<< std::endl;
}
virtual void Calc() {
std::cout << "Node::Calc()"<< std::endl;
}

};

class ChildNode: public Node {
public:
ChildNode() {
std::cout << "ChildNode()"<< std::endl;
}
virtual ~ChildNode() override {
std::cout << "~ChildNode()"<< std::endl;
}
virtual void Calc() {
std::cout << "ChildNode::Calc()"<< std::endl;
}

};

template<typename T>
class NodePtr {
private:
T* ptr_;
public:
explicit NodePtr(T* ptr=0):ptr_(ptr) {}
NodePtr(NodePtr<T>& ptr):ptr_(ptr.Release()) {}
//不同类之间，比如继承体系
template<typename U>
NodePtr(NodePtr<U>& ptr):ptr_(ptr.Release()) {}
NodePtr& operator=(NodePtr<T>& ptr) {
Reset(ptr.Release());
return *this;
}
//不同类之间，比如继承体系
template<typename V>
NodePtr& operator=(NodePtr<V>& ptr) {
Reset(ptr.Release());
return *this;
}
template<typename _Other>
operator NodePtr<_Other>() {
return (NodePtr<_Other>(*this));
}
~NodePtr() {
delete ptr_;
ptr_ = NULL;
}
T* operator->() {
//return ptr_;
return &(operator*());
}
T& operator*() {
return *ptr_;
}
T* Get() const {
return ptr_;
}
T* Release() {
T* tmp = this->ptr_;
ptr_ = NULL;
return tmp;
}
void Reset(T* ptr) {
if(ptr_ != ptr) {
delete ptr_;
}
ptr_ = ptr;
}
};

#endif // _NODEPTR_H_

main.cpp
#include <iostream>
#include <memory>
#include <vector>
using namespace std;

#include "DebugNew.h"
#include "NodePtr.h"

int main(void) {
int* p = new int;
//cout << p << endl;
delete p;

int* p2 = new int[5];
delete []p2;

//Node* node = new Node;  // 裸指针
//	NodePtr<Node> ptr(new Node);
//	ptr->Calc();
//	(*ptr).Calc();
//	NodePtr<Node> ptr2(ptr);
//	NodePtr<Node> ptr3;
//
//	ptr3 = ptr2;
//
//	//ptr2->Calc();
//	ptr3->Calc();

NodePtr<Node> ptr4(new ChildNode);

//ptr4->Calc();
NodePtr<Node> ptr5(new ChildNode);
//ptr5->Calc();
ptr4 = ptr5;
if(NULL == ptr5.Get()) {
cout << "ptr5 is NULL " << endl;
}
//ptr4->Calc();
std::auto_ptr<Node> node(new Node);
vector<std::auto_ptr<Node>> v;
//v.push_back(v);
/*
1.auto_ptr不能作为STL容器元素
2.STL容器要求存放在容器中的元素是值语义
3.auto_ptr的拷贝构造或者赋值操作 会改变 有操作数， 因为有操作数的所有权要发生转移
*/
return 0;
}

/*
合理地使用智能指针，就能够保证编码不内存泄漏C++代码
std::vector<Node*> childs_;

void AppendChild() {
childs_.push_back(node.release());
}
指针所有权释放了
vector 保存的是指针本身，并没有保存指针所指向的内存
vector 不负责指针所指向内存管理
vector 内部至少要分配4个字节的内存，才够存放
现代操作系统都支持虚拟内存
要插入的裸指针还没插入到vector， 概率低

vector析构的时候，是否会释放所指向的内存呢，他只负责指针变量本身

std::auto<Node> node(new Node);
vector<std::autor<Node> > v;
v.push_back(node);

STL容器要求存放在容器中的元素能够被拷贝，也就是要求类型是值语义对象
auto_ptr就是值语义  实际上是对象语义 转化为值语义

解决方法：可以采用其他类型的智能指针，shared_ptr, scoped_ptr
boost库，ptr_container, ptr_vector指针容器
*/

//new(__FILE__, __LINE__) int