C++：Boost 使用方法（智能指针）

参考资料：http://zh.highscore.de/cpp/boost/

智能指针

  智能指针： 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)); 
}