C++：Boost 使用方法（智能指针）
参考资料：http://zh.highscore.de/cpp/boost/
Boost 方法
- 智能指针
- RAII
- 作用域指针
- 作用域数组
- 共享指针
- 共享数组
- 弱指针
- 介入式指针
- 指针容器
智能指针
智能指针： std::auto_ptr 。 基本上就像是个普通的指针： 通过地址来访问一个动态分配的对象。 std::auto_ptr 之所以被看作是智能指针，是因为它会在析构的时候调用 delete 操作符来自动释放所包含的对象。 当然这要求在初始化的时候，传给它一个由 new 操作符返回的对象的地址。
std::auto_ptr在传递对象时，将对象的所有权传递给其他std::auto_ptr指针，也可使用release将指针所有权释放，给与对象指针。
若无智能指针，则每一个动态分配内存的函数都需要捕捉所有可能的异常，以确保在异常传递给函数的调用者之前将内存释放掉。详情请查看Boost C++ 库 Smart Pointers。
方法：
get() ：返回所含对象的地址；
reset() ：用一个新的对象来重新初始化智能指针；
release()：释放对其指针的所有权，并不调用delete；
RAII
资源申请即初始化，关键在于使用析构函数进行销毁对象，从而保证动态分配的内存得到释放
作用域指针
一个作用域指针独占一个动态分配的对象；不可直接使用‘=’更改指针指向的对象即不能将包含的对象转移给其他作用域指针，一旦使用reset转移，则使用delete释放原来的对象。
类名：
boost::scoped_ptr
位置：
boost/scoped_ptr.hpp
boost::scoped_ptr 的析构函数中使用 delete 操作符来释放所包含的对象。（注意与boost:scoped_array 类进行区分）
例子：
int main()
{
boost::scoped_ptr<int> i(new int);
*i = 1;
*i.get() = 2;
i.reset(new int);
}
作用域数组
使用方式与作用域指针相似，作用域数组的析构函数使用 delete[] 操作符来释放所包含的对象。
类名：
boost::scoped_array
位置：
boost/scoped_array.hpp
例子：
int main()
{
boost::scoped_array<int> i(new int[2]);
*i.get() = 1;
i[1] = 2;
i.reset(new int[3]);
}
共享指针
与作用域指针相似，但不一定独占一个对象。可以和其他指针共享对象有所有权，当指向对象的最后一个指针销毁之后，对象被释放。boost::shared_ptr 在内部记录着引用到某个对象的共享指针的数量。
类名：
boost::shared_ptr
位置：
boost/shared_ptr.hpp
boost::shared_ptr 的构造函数的第二个参数是一个普通函数或者函数对象，这个方法会在共享指针超出它的作用域时自动调用，可用于销毁所含的对象。
例子1：
int main()
{
boost::shared_ptr<int> i1(new int(1));
boost::shared_ptr<int> i2(i1);
i1.reset(new int(2));
}
例子2：
int main()
{
boost::shared_ptr<void> h(OpenProcess(PROCESS_SET_INFORMATION, FALSE, GetCurrentProcessId()), CloseHandle);
SetPriorityClass(h.get(), HIGH_PRIORITY_CLASS);
}
共享数组
共享数组的行为类似于共享指针，共享数组在析构时，默认使用 delete[] 操作符来释放所含的对象。
类名：
boost::shared_array
位置：
boost/shared_array.hpp
例子：
int main()
{
boost::shared_array<int> i1(new int[2]);
boost::shared_array<int> i2(i1);
i1[0] = 1;
std::cout << i2[0] << std::endl;
}
弱指针
弱指针只有在配合共享指针一起使用时才有意义。弱指针必定通过boost::shared_ptr 来初始化。
类名：
boost::weak_ptr
位置：
boost/weak_ptr.hpp
方法：
lock() ：返回boost::shared_ptr所指对象，若无则为空；
例子：
#include <windows.h>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <iostream>
//static_cast为强制转换
DWORD WINAPI reset(LPVOID p)
{
boost::shared_ptr<int> *sh = static_cast<boost::shared_ptr<int>*>(p);
sh->reset();
return 0;
}
DWORD WINAPI print(LPVOID p)
{
boost::weak_ptr<int> *w = static_cast<boost::weak_ptr<int>*>(p);
boost::shared_ptr<int> sh = w->lock();
if (sh)
std::cout << *sh << std::endl;
return 0;
}
int main()
{
boost::shared_ptr<int> sh(new int(99));
boost::weak_ptr<int> w(sh);
HANDLE threads[2];
threads[0] = CreateThread(0, 0, reset, &sh, 0, 0);
threads[1] = CreateThread(0, 0, print, &w, 0, 0);
WaitForMultipleObjects(2, threads, TRUE, INFINITE);
}
介入式指针
大体上与共享指针一致，但是需要记录自身被引用的次数。
类名：
boost::intrusive_ptr
位置：
boost/intrusive_ptr.hpp
方法：
AddRef() ：内部的引用计数增 1；
Release() ：内部的引用计数减 1，引用为0是自动销毁；
例子：
#include <boost/intrusive_ptr.hpp>
#include <atlbase.h>
#include <iostream>
void intrusive_ptr_add_ref(IDispatch *p)
{
p->AddRef();
}
void intrusive_ptr_release(IDispatch *p)
{
p->Release();
}
void check_windows_folder()
{
CLSID clsid;
CLSIDFromProgID(CComBSTR("Scripting.FileSystemObject"), &clsid);
void *p;
CoCreateInstance(clsid, 0, CLSCTX_INPROC_SERVER, __uuidof(IDispatch), &p);
boost::intrusive_ptr<IDispatch> disp(static_cast<IDispatch*>(p));
CComDispatchDriver dd(disp.get());
CComVariant arg("C:\\Windows");
CComVariant ret(false);
dd.Invoke1(CComBSTR("FolderExists"), &arg, &ret);
std::cout << (ret.boolVal != 0) << std::endl;
}
void main()
{
CoInitialize(0);
check_windows_folder();
CoUninitialize();
}
指针容器
普通的方法将指针对象存入容器时，需要频繁增减内部引用次数。指针容器提供了专门管理动态分配的对象。boost::ptr_vector 独占它所包含的对象，容器之外的共享指针不能共享所有权。
类名：
boost::ptr_vector
位置：
boost/ptr_container/ptr_vector.hpp
例子：
int main()
{
boost::ptr_vector<int> v;
v.push_back(new int(1));
v.push_back(new int(2));
}