Re: How to make this exception-safe

On Nov 18, 1:43 pm, Triple-DES <DenPlettf...@gmail.com> wrote:


While you reserve the space ahead of time, which should prevent the
push_back calls from ever failing, I'd still release the auto_ptrs
after you have finished all of the vector insertions, to be sure that
no exception can occur before we "commit" to the operation:

    std::auto_ptr<C> c1( new C(2) );
    std::auto_ptr<C> c2( new C(1) );
    std::auto_ptr<C> c3( new C(3) );

    v_.push_back( c1.get() );
    v_.push_back( c2.get() );
    v_.push_back( c3.get() );

    c1.release();
    c2.release();
    c3.release();

Of course, the above is tedious for 3, and unreasonable for 50
elements
to insert.

If you have a lot of C objects to allocate and insert, you might be
can make an array of the values and insert them with a loop.
However, remember that if something throws in the constructor, your
destructor will NOT execute, and so you will still have to do
something to cleanup the elements in the vector (since you want them
to be raw, unprotected pointers). If you cannot use smart pointers
to clean them up, you'll have to catch the exception or write your own
RAII object to manually delete the already inserted elements in the
vector. Below is an untested example of the RAII object approach,
which becomes more and more practical the more elements you insert.

namespace // anonymous
{
  // deletes and cleares given vector
  delete_vector_contents(std::vector<int> & v)
  {
    for (int i = 0; i < v.size(); ++i) {
      delete v[i];
    }
    v_.clear(); // no dangling pointers.
  }

  // RAII cleaner -- when exiting scope, this deletes/clears
  // elements in the "managed" vector unless it's reset.
  class vector_cleaner {
    public:
      vector_cleaner(std::vector<int> * v) : v_(v) {}
      void reset() { v_ = 0; }
      ~vector_cleaner() {
        if (v_) {
          (delete_vector_contents(*v_);
        }
      }
    private:
      std::vector<int> * v_;
  }

} // anonymous

V::V()
{
   int elements[] = {2, 1, 3};
   int const size = sizeof(elements[0])/sizeof(elements[0]);
   v_.resize(size);
   vector_cleaner cleaner(&v_); // <<< this protects your objects

   for (int i = 0; i < size; ++i)
     v_[i] = new C(elements[i]);
   }

   cleaner.reset(); // << no exception, so disable the cleaner
}

V::~V() {
  delete_vector_contents(v_);
}

--
Chris

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]