If an exception is thrown in the constructor, the best way is to prevent memory leakage?

If an exception is thrown in the constructor , Destructors will not be called ( Simple class , No inheritance ). therefore , If an exception is thrown in the constructor , And there are some chances that the heap memory has not been cleared . So what's the best thing to do here ？

If you avoid “ bare ” resources ( Such as bare pointer , Bare mutexes, etc ), And include all the contents in the appropriate RAII Behavior in a container or class , So even if there are exceptions , There will be no problem as you described .

in other words , Do not get raw resources in the constructor . Instead, create one that follows itself RAII Instance of the object . such , Even if your constructor fails ( That is, create the constructor of the instance ), The destructor of the initialization object will be called .

therefore , It's not a good idea ：

#include<iostream>
#include<stdexcept>
 
struct Bad {
    
  Bad() {
    
    double *x = new double;
    throw(std::runtime_error("the exception was thrown"));
  }
 
  ~Bad() {
    
    delete x;
    std::cout<<"My destructor was called"<<std::endl;
  }
 
  double *x;  
};
 
int main() {
    
  try {
    
    Bad bad;
  } catch (const std::exception &e) {
    
    std::cout<<"We have a leak! Let's keep going!"<<std::endl;
  }
  std::cout<<"Here I am... with a leak..."<<std::endl;
  return 0;
}

Output ：

We have a leak! Let's keep going!
Here I am... with a leak...

An example of correction ：

#include<iostream>
#include<stdexcept>
 
struct Resource {
    
 
  Resource() {
    
    std::cout<<"Resource acquired"<<std::endl;    
  }
 
  ~Resource() {
    
    std::cout<<"Resource cleaned up"<<std::endl;        
  }
 
};
 
struct Good {
    
  Good() {
    
    std::cout<<"Acquiring resource"<<std::endl;
    Resource r;
    throw(std::runtime_error("the exception was thrown"));
  }
 
  ~Good() {
    
    std::cout<<"My destructor was called"<<std::endl;
  }  
};
 
 
int main() {
    
  try {
    
    Good good;
  } catch (const std::exception &e) {
    
    std::cout<<"We DO NOT have a leak! Let's keep going!"<<std::endl;
  }
  std::cout<<"Here I am... without a leak..."<<std::endl;
  return 0;
}

Output ：

Acquiring resource
Resource acquired
Resource cleaned up
We DO NOT have a leak! Let's keep going!
Here I am... without a leak...

My opinion is as follows ： Try to encapsulate all resources that need to be liberated into classes that the constructor does not throw , Destructors correctly release resources . then , In other classes that the destructor may throw , Just create an instance of the wrapper resource , And it will ensure that the destructor of the obtained resource wrapper will be cleaned up .

The following may be a better example ：

#include<mutex>
#include<iostream>
#include<stdexcept>
 
// a program-wIDe mutex
std::mutex TheMutex;
 
struct Bad {
    
  Bad() {
    
    std::cout<<"Attempting to get the mutex"<<std::endl;
    TheMutex.lock();
    std::cout<<"Got it! I'll give it to you in a second..."<<std::endl;
    throw(std::runtime_error("Ooops,I threw!"));
    // will never get here...
    TheMutex.unlock();
    std::cout<<"There you go! I released the mutex!"<<std::endl;    
  }  
};
 
struct ScopedLock {
    
  ScopedLock(std::mutex& mutex)
      :m_mutex(&mutex) {
    
    std::cout<<"Attempting to get the mutex"<<std::endl;
    m_mutex->lock();
    std::cout<<"Got it! I'll give it to you in a second..."<<std::endl;    
  }
 
  ~ScopedLock() {
    
    m_mutex->unlock();
    std::cout<<"There you go! I released the mutex!"<<std::endl;        
  }
  std::mutex* m_mutex;      
};
 
struct Good {
    
  Good() {
    
    ScopedLock autorelease(TheMutex);
    throw(std::runtime_error("Ooops,I threw!"));
    // will never get here
  }  
};
 
 
int main() {
    
  std::cout<<"Create a Good instance"<<std::endl;
  try {
    
    Good g;
  } catch (const std::exception& e) {
    
    std::cout<<e.what()<<std::endl;
  }
 
  std::cout<<"Now,let's create a Bad instance"<<std::endl;
  try {
    
    Bad b;
  } catch (const std::exception& e) {
    
    std::cout<<e.what()<<std::endl;
  }
 
  std::cout<<"Now,let's create a whatever instance"<<std::endl;
  try {
    
    Good g;
  } catch (const std::exception& e) {
    
    std::cout<<e.what()<<std::endl;
  }
 
  std::cout<<"I am here despite the deadlock..."<<std::endl;  
  return 0;
}

Output ( use gcc 4.8.1 compile , Use -std = c 11)：

Create a Good instance
Attempting to get the mutex
Got it! I'll give it to you in a second...
There you go! I released the mutex!
Ooops,I threw!
Now,let's create a Bad instance
Attempting to get the mutex
Got it! I'll give it to you in a second...
Ooops,let's create a whatever instance
Attempting to get the mutex