RAII 到底贵不贵：我把 C++ 的资源管理拆到了汇编

1
// Four exit paths, one of them forgets std::free().
2
bool ProcessManual(const char* path) {
3
  std::FILE* f = std::fopen(path, "rb");
4
  if (!f) return false;
5

6
  char* buf = static_cast<char*>(std::malloc(1024));
7
  if (!buf) {
8
    std::fclose(f);
9
    return false;
10
  }
11

12
  buf[0] = '\0';
13
  if (!Consume(buf)) {
14
    std::fclose(f);  // Leaks buf.
15
    return false;
16
  }
17

18
  std::free(buf);
19
  std::fclose(f);
20
  return true;
21
}

1
struct FileCloser {
2
  void operator()(std::FILE* f) const {
3
    if (f) {
4
      std::fclose(f);
5
    }
6
  }
7
};
8

9
using FilePtr = std::unique_ptr<std::FILE, FileCloser>;
10

11
bool ProcessRaii(const char* path) {
12
  FilePtr f(std::fopen(path, "rb"));
13
  if (!f) return false;
14

15
  auto buf = std::make_unique<char[]>(1024);
16
  buf[0] = '\0';
17
  if (!Consume(buf.get())) return false;
18

19
  return true;
20
}

1
namespace {
2

3
long g_new_count = 0;
4
long g_delete_count = 0;
5
// Keeps the allocation observable, so the compiler cannot elide it.
6
volatile void* g_escape = nullptr;
7

8
void* CountAlloc(std::size_t n) {
9
  ++g_new_count;
10
  if (void* p = std::malloc(n)) return p;
11
  throw std::bad_alloc();
12
}
13

14
}  // namespace
15

16
void* operator new(std::size_t n) { return CountAlloc(n); }
17
void* operator new[](std::size_t n) { return CountAlloc(n); }
18

19
void operator delete(void* p) noexcept {
20
  if (p) {
21
    ++g_delete_count;
22
    std::free(p);
23
  }
24
}
25

26
void operator delete[](void* p) noexcept {
27
  if (p) {
28
    ++g_delete_count;
29
    std::free(p);
30
  }
31
}
32

33
void operator delete(void* p, std::size_t) noexcept { operator delete(p); }
34

35
void operator delete[](void* p, std::size_t) noexcept {
36
  operator delete[](p);
37
}

1
struct Boom {};
2

3
struct Resource {
4
  char pad[64];
5
};
6

7
struct Failing {
8
  Failing() { throw Boom{}; }
9
};
10

11
class RawHolder {
12
 public:
13
  RawHolder() : resource_(new Resource), failing_(new Failing) {}
14
  ~RawHolder() {
15
    delete failing_;
16
    delete resource_;
17
  }
18

19
 private:
20
  Resource* resource_;
21
  Failing* failing_;
22
};

1
class Tracer {
2
 public:
3
  explicit Tracer(const char* name) : name_(name) {
4
    std::printf("  ctor  %s\n", name_);
5
  }
6
  ~Tracer() { std::printf("  dtor  %s\n", name_); }
7

8
 private:
9
  const char* name_;
10
};
11

12
struct Base {
13
  Tracer tracer{"Base"};
14
};
15

16
struct MemberA {
17
  Tracer tracer{"member a (declared 1st)"};
18
};
19

20
struct MemberB {
21
  Tracer tracer{"member b (declared 2nd)"};
22
};
23

24
class Derived : public Base {
25
 public:
26
  Derived() = default;
27

28
 private:
29
  MemberA a_;
30
  MemberB b_;
31
  Tracer body_{"Derived ctor body"};
32
};
33

34
int main() {
35
  std::printf("-- enter main --\n");
36
  {
37
    Tracer first{"local 1 (outer scope)"};
38
    Tracer second{"local 2 (outer scope)"};
39
  }
40
  std::printf("-- locals gone, now build Derived --\n");
41
  Derived d;
42
  std::printf("-- leaving main --\n");
43
}

1
long g_sink = 0;
2
// volatile keeps the constructor/destructor side effects observable.
3
volatile int g_live = 0;
4
volatile void* g_escape = nullptr;
5

6
void MayThrow();
7

8
class Widget {
9
 public:
10
  explicit Widget(int value) : value_(value) { g_live = g_live + 1; }
11
  ~Widget() { g_live = g_live - 1; }
12

13
  int value() const { return value_; }
14

15
 private:
16
  int value_;
17
};
18

19
void ManualHot(int n) {
20
  long sum = 0;
21
  for (int i = 0; i < n; ++i) {
22
    Widget* w = new Widget(i);
23
    g_escape = w;
24
    sum += w->value();
25
    g_escape = nullptr;
26
    delete w;
27
  }
28
  g_sink = sum + g_live;
29
}
30

31
void RaiiHot(int n) {
32
  long sum = 0;
33
  for (int i = 0; i < n; ++i) {
34
    auto w = std::make_unique<Widget>(i);
35
    g_escape = w.get();
36
    sum += w->value();
37
    g_escape = nullptr;
38
  }
39
  g_sink = sum + g_live;
40
}

1
void ManualUnwind(int n) {
2
  long sum = 0;
3
  for (int i = 0; i < n; ++i) {
4
    Widget* w = new Widget(i);
5
    g_escape = w;
6
    sum += w->value();
7
    MayThrow();  // 这里抛异常
8
    g_escape = nullptr;
9
    delete w;    // 到不了
10
  }
11
  g_sink = sum + g_live;
12
}
13

14
void RaiiUnwind(int n) {
15
  long sum = 0;
16
  for (int i = 0; i < n; ++i) {
17
    auto w = std::make_unique<Widget>(i);
18
    g_escape = w.get();
19
    sum += w->value();
20
    MayThrow();  // 这里抛异常
21
    g_escape = nullptr;
22
  }
23
  g_sink = sum + g_live;
24
}

1
template <typename F>
2
class ScopeGuard {
3
 public:
4
  explicit ScopeGuard(F f) : f_(std::move(f)) {}
5
  ScopeGuard(ScopeGuard&& other) noexcept
6
      : f_(std::move(other.f_)), active_(std::exchange(other.active_, false)) {}
7
  ScopeGuard(const ScopeGuard&) = delete;
8
  ScopeGuard& operator=(const ScopeGuard&) = delete;
9
  ~ScopeGuard() {
10
    if (active_) {
11
      f_();
12
    }
13
  }
14

15
  void dismiss() noexcept { active_ = false; }
16

17
 private:
18
  F f_;
19
  bool active_ = true;
20
};
21

22
template <typename F>
23
ScopeGuard<F> MakeScopeGuard(F f) {
24
  return ScopeGuard<F>(std::move(f));
25
}