【C++ Primer 第十二章】 shared_ptr和new的结合使用

shared_ptr和new的结合使用

• 如果我们不初始化一个智能指针，它就会被初始化一个空指针。

• 一个shared_ptr默认初始化为一个空指针。我们也可以使用new返回的指针来初始化一个shared_ptr：

shared_ptr<double> p1;                // shared_ptr可以指向一个double
shared_ptr<int> p2(new int(42));      // p2指向一个值为42的int  

• 接受指针参数的智能指针构造函数是explicit的。因此，我们不能将一个内置指针隐式的转换为一个智能指针，必须使用直接初始化形式：

shared_ptr<int> p1(new int(42));      // p1指向一个值为42的int
shared_ptr<int> p2 = new int(1024);   // 错误，不能将一个内置指针隐式转化为智能指针。

 1 shared_ptr<int> clone(int p)
 2 {
 3     return new int(p);        // 错误，不能隐式转化
 4
 5 }
 6
 7 shared_ptr<int> clone(int p)
 8 {
 9     return shared_ptr<int>(new int(p));   // 正确
10 }

定义和改变shared_ptr的其他方法

• 默认情况下，一个用来初始化智能指针的普通指针必须指向动态内存，因为智能指针默认使用delete释放它所关联德邦对象。

不要混合使用普通指针和智能指针

考虑下面对shared_ptr进行操作的函数：

void process(shared_ptr<int> ptr)
{
   // 使用ptr
}  // ptr离开作用域，被销毁  

使用次函数的正确方法是传递给它一个shared_ptr：

shared_ptr<int> p(new int(42));   // 引用计数为1
process(p);                       // 拷贝p，在函数结束前引用计数为2，函数执行结束后，引用计数变为1
int i = *p;                       // i == 42

由于不能将一个内置指针隐式转换为一个shared_ptr，因此，我们不能将一个内置指针直接传递给process函数，但可以传递给它一个临时的shared_ptr，这个shared_ptr使用一个内置指针显示构造的：

int* x(new int(1024));
process(x);                      // 错误，不能将一个int*转换为一个shared_ptr，因位构造函数时explicit的
process(shared_ptr<int>(x));    // 合法的，但x所管理的内存会被释放  

int j = *x;     // 错误，x是一个空悬指针！  

也不要使用get初始化另一个智能指针或为智能指针

• 智能指针类定义了一个get的成员函数，该成员函数返回一个内置指针，指向智能指针管理的对象。此函数为了向不使用智能指针的代码传递一个普通指针，使用get返回的指针的代码不能delete此指针。

将一个智能指针绑定到get返回的指针上时错误的：

 1 shared_ptr<int> p(new int(1024));
 2 int* q = p.get();
 3
 4 { // 新的作用域
 5
 6     shared_ptr<int> p1(p);
 7
 8 } // 作用域结束，p1被销毁，p1所管理的对象被释放
 9
10 int foo = *p; // 未定义，p指向的内存已经被释放了  

其他shared_ptr操作

• reset操作：

p = new int(1024);       // p是一个shared_ptr类型， 发生错误，不能将一个指针赋予shared_ptr
p.reset(new int(1024));  // p指向一个新对象  

• unique操作： 如果一个shared_ptr对象唯一指向它所管理的内存对象，则返回true。

if (!p.unique())     // 如果p补是它所管理对象的唯一引用者，则为它重新分配
   p.reset(new int(100));
*p += newVal;        // 现在p是唯一的用户，可以改变对象的值  

智能指针和异常

• 如果程使用智能指针， 即使程序过早结束，智能指针也能确保内存不再需要时将其释放。

void f()
{
    shared_ptr<int> sp(new int(42));
    // 抛出异常，未在f中捕获
    // 函数结束后shared_ptr正确释放资源
} 

• 如果在new和delete之间发生异常，且异常未在f中捕获，则内存永远不能释放。在函数之外没有指针指向这块内存，异常就无法释放它。

void f()
{
    int* ip = new int(42);
    // 发生异常，且在f中未捕获
    delete ip;
}   

原文地址：https://www.cnblogs.com/sunbines/p/8946600.html