C++ code became no-linear when using exception - c++

Question

I've project which the main look like that
Object a;
if (! a.initialize(x, y, z))
return EXIT_FAILURE;
// 100 lines using a
a.finalize();
I trying to change this part of code and using RAII idiome.
So, I delete initialize function and finalize and move the code in the constructor and destructor.
In order to catch initialize() error, I throw an exception in the constructor if something fail.
So now, my code goes like this :
try
{
Object a(x, y, z);
// 100 lines using a
} catch (my_exception&)
{
return EXIT_FAILURE;
}
the think that bother is the 100 lines of code. My try is too long for just one error. And I've multiple object like a.
so before my code was linear :
Object a;
if (! a.initialize(x, y, z))
return EXIT_FAILURE;
Object b;
Object c;
if (!b.initialize() || !c.initialize())
return EXIT_FAILURE;
a.finalize();
Now it looks ugly, difficult to read :
try
{
Object a(x, y, z);
try
{
Object b;
try
{
Object c;
}
catch (my_exception_c&)
{
return EXIT_FAILURE;
}
}
catch (my_exception_b&)
{
return EXIT_FAILURE;
}
} catch (my_exception&)
{
return EXIT_FAILURE;
}
How to do to use RAII and keep a code clear ?

Answer 1

In general, create a try block at the level at which you want to handle the exception. In this case, you just need a top-level block to clean up after any exception:
try {
Object a(x, y, z);
Object b;
Object c;
// code using these
} catch (...) {
// end the program if any exception hasn't been handled
return EXIT_FAILURE;
}
Now it's not "too long for one error"; it's the right length for any error which might occur.
It would be a good idea to restrict yourself to exceptions derived from std::exception; then you could give some potentially useful information in the case that it's not handled:
catch (std::exception const & ex) {
std::cerr << "ERROR: " << ex.what() << std::endl;
return EXIT_FAILURE;
}

Answer 2

You only need one catch like this:
try
{
Object a;
Object b;
//100 lines of code
}
catch(ExeptionA& exa)
{
cerr << "error a" << endl;
}
catch(ExeptionB& exa)
{
cerr << "error B" << endl;
}
catch(...){
cerr << "some other error" << endl;
}
(the '...' literally means '...')
This way, you'll catch all exeptions from ObjectA and ObjectB etc. in the same catch. So if you make a custom exception, it might be good to add some info in there where it came from.

Answer 3

You can always have another function like "IsValid()" that you check after the constructor is called instead of throwing an exception. You keep the benefits of RAII (exception safety, protection against initialization/destruction errors, ...) but you will be able to keep your code in the same format as before.
It's not as clean and safe in terms of C++ good practices, because the user can forget to check if it is valid, but the option is there.