Returning from multiple points

If your function needs to return from multiple points and it's allocating memory, you need to be very careful to ensure that you free the memory before each return point.

Consider this example:

1int* func(bool cond) {
2  int* ptr = new int(10);
3  if (cond) {
4    return ptr; // Potential leak if cond is true
5  }
6
7  delete ptr;
8  return nullptr;
9}

If cond is true, the function will return without deleting ptr, causing a leak.

One way to handle this is to duplicate the deallocation code:

1int* func(bool cond) {
2  int* ptr = new int(10);
3  if (cond) {
4    delete ptr;
5    return nullptr;
6  }
7
8  delete ptr;
9  return nullptr;
10}

However, this can lead to code duplication and is error-prone if you later add more return points.

A better solution is to use a smart pointer:

1#include <memory>
2
3std::unique_ptr<int> func(bool cond) {
4  std::unique_ptr<int> ptr{
5    std::make_unique<int>(10)};
6
7  if (cond) {
8    return nullptr;
9  }
10
11  return ptr;
12}

Now, regardless of where the function returns, the memory will be properly deallocated.

Another solution is to use a single return point:

1int* func(bool cond) {
2  int* ptr = new int(10);
3  int* result = nullptr;
4
5  if (!cond) {
6    // ...
7    result = ptr;
8  }
9
10  if (!result) {
11    delete ptr;
12  }
13  return result;
14}

This way, you can ensure that the deallocation code executes regardless of the condition.

In general, smart pointers are the preferred solution for this problem in modern C++.