包括

Question

给定一个类层次结构：

class A {

private:
  string * p_str;

public:
  A() : p_str(new string())
  {
  }

  virtual ~A() {
    delete p_str;
  }
};

class B : public A {
public:
  B() {
  }

  virtual ~B() override {
  }

  virtual void Test() {
    cout << "B::Test()" << endl;
  }
};

int main(int, char**)
{
  B b;

  b.Test();

    return 0;
}

指向字符串的p_str指针（无论它指向什么对象）。

除了不写std::unique_ptr之外，将其替换为delete p_str是否有任何好处？

class A {

private:
  std::unique_ptr<string> p_str;

public:
  A() : p_str(make_unique<string>())
  virtual ~A() {}

}

？如果任何派生类的构造函数抛出异常，则在任何代码变体中都会发生内存泄漏。

UPD 我试过这段代码：

包括

#include <memory>
using namespace std;

class Pointed {
public:
  Pointed() { std::cout << "Pointed()\n"; }
  ~Pointed() { std::cout << "~Pointed()\n"; }
};

class A1 {
private:
  Pointed * p_str;

public:
  A1() : p_str(new Pointed()) {
    cout << "A1()\n";
    throw "A1 constructor";
  }

  virtual ~A1() {
    cout << "~A1()\n";
    delete p_str;
  }
};

class B1 : public A1 {
public:
  B1() {
    throw "B constructor";
  }

  virtual ~B1() override {
    cout << "~B1()\n";
  }

  virtual void Test() {
    cout << "B1::Test()" << endl;
  }
};

class A2 {
private:
  std::unique_ptr<Pointed> p_str;

public:
  A2() : p_str(make_unique<Pointed>()) {
    cout << "A2()\n";
    throw "A2 constructor";
  }

  virtual ~A2() {
    cout << "~A2()\n";
  }
};


class B2 : public A2 {
public:
  B2() {
    cout << "B2()\n";
    throw "B2 constructor";
  }

  virtual ~B2() override {
    cout << "~B2()\n";
  }

  virtual void Test() {
    cout << "B2::Test()" << endl;
  }
};

int main(int, char**) {
  cout << "B1::A1 (raw pointers)\n";

  try {
    B1 b1;
  }
  catch (...) {
    cout << "Exception thrown for B1\n";
  }

  cout << "\nB2::A2 (unique pointers)\n";

  try {
    B2 b2;
  }
  catch (...) {
    cout << "Exception thrown for b2\n";
  }

  cin.get();

  return 0;
}

输出是：

B1::A1 (raw pointers)
Pointed()
A1()
Exception thrown for B1

B2::A2 (unique pointers)
Pointed()
A2()
~Pointed()
Exception thrown for b2

因此，结果是在声明成员的同一个类的构造函数中发生异常时会自动删除unique_ptr。

Answer 1

使用原始指针，您可以进行双重删除，因为您没有手动实现的复制c-tor和赋值运算符。

A a;
A b = a; // b.p_str store the same address, that a.p_str

使用unique_ptr您无法复制/分配对象，但您可以移动它，而无需编写移动控制/移动赋值运算符。

A a;
A b = a; // cannot do this, since `unique_ptr` has no copy constructor.
A b = std::move(a); // all is okay, now `b` stores `unique_ptr` with data and `a` stores `nullptr`

但实际上，我不知道为什么你应该在这里存储指针，而不仅仅是std::string类型的对象，这是你的例子中最好的解决方案。

Answer 2

除了ForEveR的回复之外，使用unique_ptr告诉读者只有一个对象引用（并且在这种情况下，拥有）该字符串。使用裸指针，无论谁在阅读你的代码，都不知道有多少其他对象，本地人或其他任何东西（单身人士？全球？？）访问和/或修改该字符串。

智能指针（unique_ptr）而不是原始指针作为类成员

包括

2 个答案: