What to do when an exception is thrown on the initialization list when allocating memory for a raw pointer? The situation is easy if your class only has one raw pointer member, but it gets complicated with two or more. Here’s a code example that’s guaranteed to leak memory if the second new int throws an exception (because the destructor will not be called):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
struct bad { bad() : p1(new int), p2(new int) { *p1 = 1; *p2 = 2; } ~bad() { delete p1; delete p2; } int* p1; int* p2; }; |
There is no way to free the memory allocated to p1 if p2(new int) throws! Let’s build on my previous example and see what happens if we use a function try-catch block on the constructor:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
struct still_bad { still_bad() try : p1(new int), p2(new int) { *p1 = 1; *p2 = 2; } catch(...) { if(p1) delete p1; // ILLEGAL~!!! if(p2) delete p2; // ILLEGAL~!!! /* * From: https://en.cppreference.com/w/cpp/language/function-try-block * * The behavior is undefined if the catch-clause of a function-try-block used on a * constructor or a destructor accesses a base or a non-static member of the object. */ } ~still_bad() { delete p1; delete p2; } int* p1 = nullptr; int* p2 = nullptr; }; |
Still no good! Because accessing p1 and p2 in the catch block leads to undefined behavior. See here.
The only way to guarantee correct behavior is to use smart pointers. This works because 1) the initialization list allocates in pre-defined order (the order of member declaration) and 2) the destructors of already created members will be called. Here’s the correct way of allocating multiple pointers:
|
1 2 3 4 5 6 7 8 9 10 11 |
struct good { good() : p1(make_unique<int>()), p2(make_unique<int>()) { *p1 = 1; *p2 = 2; } unique_ptr<int> p1; unique_ptr<int> p2; }; |
This is guaranteed to do proper cleanup if the second make_unique<int>() throws std::bad_alloc 🙂
Complete listing (bad_pointer.cpp):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
#include <iostream> #include <memory> using namespace std; struct bad { bad() : p1(new int), p2(new int) { *p1 = 1; *p2 = 2; } ~bad() { delete p1; delete p2; } int* p1; int* p2; }; struct still_bad { still_bad() try : p1(new int), p2(new int) { *p1 = 1; *p2 = 2; } catch(...) { if(p1) delete p1; // ILLEGAL~!!! if(p2) delete p2; // ILLEGAL~!!! /* * From: https://en.cppreference.com/w/cpp/language/function-try-block * * The behavior is undefined if the catch-clause of a function-try-block used on a * constructor or a destructor accesses a base or a non-static member of the object. */ } ~still_bad() { delete p1; delete p2; } int* p1 = nullptr; int* p2 = nullptr; }; struct good { good() : p1(make_unique<int>()), p2(make_unique<int>()) { *p1 = 1; *p2 = 2; } unique_ptr<int> p1; unique_ptr<int> p2; }; int main() { bad b; still_bad sb; good g; } |