抛出析构函数导致内存泄漏答案

【问题标题】：Throwing destructor causes memory leak抛出析构函数导致内存泄漏
【发布时间】：2021-06-30 14:27:05
【问题描述】：

这段代码

#include <iostream>
#include <memory>

template <typename T>
class ScopeGuard final {
 public:
  explicit ScopeGuard(T callback) : callback_(std::move(callback)) {}

  ScopeGuard(const ScopeGuard&) = delete;
  ScopeGuard(ScopeGuard&&) = delete;

  ScopeGuard& operator=(const ScopeGuard&) = delete;
  ScopeGuard& operator=(ScopeGuard&&) = delete;

  ~ScopeGuard() noexcept(false) { callback_(); }

 private:
  T callback_;
};

static int a_instances = 0;

struct A {
  A() {
    ++a_instances;
    std::cout << "ctor" << std::endl;
  }
  A(A&&) = delete;
  A(const A&) = delete;
  ~A() {
    --a_instances;
    std::cout << "dtor" << std::endl;
  }
};

struct Res {
  std::shared_ptr<A> shared;

  explicit Res(std::shared_ptr<A> shared) : shared(shared) {
    std::cout << "res ctor" << std::endl;
  }

  Res(Res&& o) : shared(std::move(o.shared)) {
    std::cout << "res mv" << std::endl;
  }

  Res(const Res& o) : shared(o.shared) { std::cout << "res cp" << std::endl; }

  ~Res() { std::cout << "res dtor" << std::endl; }
};

Res LeakImpl() {
  ScopeGuard on_exit{[] { throw std::runtime_error("error"); }};
  Res res{std::make_shared<A>()};
  return res;
}

void Leak() {
  try {
    auto res = LeakImpl();
  } catch (const std::exception& e) {
    std::cout << e.what() << std::endl;
  }
}

int main() {
  Leak();
  if (a_instances) {
    std::cout << "leak, instances count: " << a_instances << std::endl;
  }
  return 0;
}

输出这个（GCC 9.1、GCC 11.1 和 Clang 9.0.1）

ctor
res ctor
error
leak, instances count: 1

这意味着既没有调用A::~A()，也没有调用Res::~Res()，导致这种情况导致内存泄漏。

我想 LeakImpl() Res::~Res() 在 ScopeGuard::~ScopeGuard 之前因为复制省略而没有被调用，但是为什么当从 ScopeGuard::~ScopeGuard 抛出的异常离开 try 块时它没有被调用？

如果我像这样更改LeakImpl()：

Res LeakImpl() {
  ScopeGuard on_exit{[] { throw std::runtime_error("error"); }};
  return Res{std::make_shared<A>()};
}

然后 GCC 11.1 生成的二进制输出如下：

ctor
res ctor
res dtor
dtor
error

没有泄漏

在 GCC 9.1 和 Clang 9.0.1 上，该错误仍然存在。

在我看来，这看起来像是编译器中的一个错误，你有什么想法？

【问题讨论】：

Do not allow a destructor to emit an exception.
@FredLarson 感谢您的链接！阅读。我在那里看到的唯一客观（不是概念上）的论点是从不从析构函数中抛出，是堆栈展开期间的潜在抛出，导致进程终止。我故意发布了ScopeGuard 的简化版本，以使示例更易于阅读。实际上我的ScopeGuard 检查堆栈展开是否正在进行，如果是，它只是记录异常，所以它永远不会直接导致std::terminate。如果你认为我错过了为什么析构函数永远不应该抛出的其他客观原因，请告诉我。
有一个非常广泛的经验法则，即析构函数必须始终为nothrow，因此有可能存在与抛出析构函数相关的编译器错误。与更主流的问题相比，它不太可能被发现，并且它可能具有较低的错误修复优先级。据我所知，泄漏是没有原因的。

标签： c++ memory-leaks c++17 smart-pointers

【解决方案1】：

似乎是一个错误，已为 gcc 报告并修复：https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66139

我想，std::shared_ptr<> 是在异常抛出期间部分创建的

作为一种解决方法，您可以防止复制省略：

Res LeakImpl() {
  ScopeGuard on_exit{[] { throw std::runtime_error("error"); }};
  Res res{std::make_shared<A>()};
  return std::move(res);
}

或在Res 之前创建ScopeGuard（在这种情况下，销毁顺序很重要）：

Res LeakImpl() {
  Res res{std::make_shared<A>()};
  ScopeGuard on_exit{[] { throw std::runtime_error("error"); }};
  return res;
}

【讨论】：

看起来像。不过还没有修复。