How to handle an exception thrown by new in C++?

Question

I have a class with assignment operator as below.

char *buff;
myString& operator= ( const myString& other )
{
  cout << "  myString::operator=\n";
  if( this != &other ){      
    cout<<"my string ="<<endl;
    delete [] buff;              
    length = other.length;      
    buff = new char[length];
    my_strncpy( buff, other.buff, length );
  }
  return *this;   
}

I am deleting memory for buff and allocating with length of new string. How can I handle any exception that happens during the allocation memory with new? How can I restore the value of buff to old values incase of exception?

This seems an easy question to answer but is it really what you are looking for. You can store the value in some globale temp variable before deleteing the buffer. You may get an `bad_alloc` exception with this code and same can be handled using a try catch block. — Vinay Shukla, Jul 20 '15 at 11:05
First of all you need to decide whether that is a reasonable course of action when running out of memory. An object silently retaining its old value after an assignment sounds iffy at best. — molbdnilo, Jul 20 '15 at 11:08
The easier solution is to use `std::vector` for your memory allocation purposes. — MSalters, Jul 20 '15 at 12:11

score 2 · Answer 1 · edited May 23 '17 at 12:02

There are two solutions to this. The first (best) is to use copy-and-swap:

myString& operator= ( myString other ) {
    swap (*this, other);
    return *this;
}

If allocation fails in the copy constructor, we'd never get to the swap, so there's no worry about overwriting our current state. For more, see What is copy-and-swap?

The other approach is to just make sure you only delete if it's safe. That is, do it after the new:

tmp_buff = new char[other.length];
// either that threw, or we're safe to proceed
length = other.length;
my_strncpy(tmp_buff, other.buff, length);
delete [] buff;              
buff = tmp_buff;

score 0 · Answer 2 · answered Jul 20 '15 at 11:05

Dealing with out-of-memory conditions is hard since there often is no easy failure path that can be used.

In your case, you could try creating the new buffer before deleting the old buffer but this may increase the likelyhood of running out of memory (OOM).

Ideally you should probably use the old buffer if it is big enough and only create a new buffer if the old one is too small. In such a case it is probably ill advised to use the old buffer in the event of OOM since it will be too small to store the string.

score 0 · Answer 3 · edited May 23 '17 at 10:24

How can I handle any exception that happens during the allocation memory with new?

A try{} catch(){} should be used to catch exceptions thrown during allocation and object creation.

How can I restore the value of buff to old values incase of exception?

The key here is not really to restore the old values if an exception is thrown, but to first allocate and copy the contents, swapping pointers etc. and then delete the old object and memory. In this way if an exception is thrown, the current contents are left unchanged.

First allocate the memory to a temporary pointer, copy the data required, then swap the new pointer for the old one and delete the old data; akin to the copy-swap idiom. GotW (#59) also has a nice article on this here.

myString& operator= ( const myString& other )
{
  if( this != &other ){
    try {      
      char* temp_buff = other.length ? new char[other.length] : nullptr;
      // I assume my_strncpy handle NULL pointers etc.
      // If not, call it behind an if check for length and pointer validity
      my_strncpy( temp_buff, other.buff, length );
      std::swap(temp_buff, buff);
      delete [] temp_buff;              
      length = other.length;
    }
    catch (std::bad_alloc& e) {
      // deal with the bad_alloc...
    }      
    catch (std::exception& e) {
      // deal with the exception
    }      
  }
  return *this;   
}

In general, out of memory conditions are significant, so just catching the exception may not always be ideal - it needs to be dealt with by the application as a whole, possibly even by the user for the entire system. A question to ask yourself is; what are you going to do with the exception, how are you going to recover from it?

A more general solution (I assume you really are focused on implementing the operator= in the current form) is to use a full blown copy-swap implementation.

class myString {
  char* buff;
  std::size_t length;
  // ...
};

myString::myString(myString const& src) :
buff(src.length ? new char[src.length] : nullptr),
length(src.length)
{
  if (length)
    std::copy(src.buff, src.buff + length, buff);
}

myString::~myString()
{
  delete [] buff;
  length = 0;
}

void myString::swap(myString& rhs)
{
  std::swap(rhs.buff, this->buff);
  std::swap(rhs.length, this->length);
}

myString& myString::operator=(myString const& rhs)
{
  if (this != &rhs) {
    myString temp(rhs);
    swap(temp);
  }
  return *this;
}

// the rest of the class implementation

//... non-member swap for addition utility
inline void swap(myString& lhs, myString& rhs)
{
  lhs.swap(rhs);
}

what do you mean by the code std::swap(temp_buff, buff); delete [] temp_buff; — sasikala, Jul 20 '15 at 11:32
@sasikala. `std::swap` will swap the value of pointers (not what is being pointed to), so the old is now in the place of the new and vice verse. The `delete[]` then deletes the old data. — Niall, Jul 20 '15 at 11:34
see my comment myString& operator= ( const myString& other ) { if( this != &other ){ try { delete []buff; length = other.length; //after deleting memory for buff i got exception in allocating memory for buff again try { buff = new char[other.length];//if i get exception here, statement beyond this point will not be executed. //in this case how do we get old values into buff. } catch (std::bad_alloc& e) { // deal with the bad_alloc... } catch (std::exception& e) { // deal with the exception } } — sasikala, Jul 21 '15 at 04:37
@sasikala. What exception do you get when allocating the buffer? — Niall, Jul 21 '15 at 06:54
we can say bad_alloc exception. when ever it happens we cannot execute the statements after buff = new char[other.length]. Am I right? then is there any way to restore the values. — sasikala, Jul 21 '15 at 08:53
@sasikala. Correct, exceptions change the program flow, statements after the exception are not executed. The only why to "restore" the values then is to change them back in the `catch`. It is considered better to not restore the values, but to allocate and copy before changing the objects pointers, then clean up the old values. — Niall, Jul 21 '15 at 09:15
@sasikala. Excellent. Consider accepting on answer that [works for you](http://stackoverflow.com/help/accepted-answer). — Niall, Jul 21 '15 at 09:31

How to handle an exception thrown by new in C++?

3 Answers3