Re: Is it possible to catch an exception raised by a member variable?
On Sep 28, 7:03 pm, James Kanze <james.ka...@gmail.com> wrote:
On Sep 27, 8:12 pm, "Chris ( Val )" <chris...@gmail.com> wrote:
On Sep 28, 2:22 am, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
Angus wrote:
I have a class I am using which raises an exception in its constructor
if certain things aren't in place. I can easily create the situation
where an exception is raised.
OK. So creation of a subobject fails. Quite common.
If I use the create a member variable in a class using this class then
how do I catch the exception?
The exception has to be caught by the code that instantiates (or rather
tries to instantiate) the host object.
For now I have defined a member function as a pointer and in my
constructor in my class using the class which raises the exception, I
do a try catch block and do a new object. That works. But is it
possible to do a similar thing using a member variable?
Yes, but if your member fails to be constructed, can your object still
exist and function? If it can, you should use the pointer solution,
which apparently works. If your object cannot exist and function with
some part of it missing, then you should do nothing, the constructor
of the entire object will throw (because some part of it throws), and
the exception has to be caught outside.
I think it can still be created and exist under certain
circumstances:
Not if the construction of a sub-object fails.
For example:
You could use a function try block, which will then catch the
exception in the initialiser list, prior to executing the body
of the constructor, therefore the object is still alive to an
extent, as it is still in the process of being created.
The try block itself becomes the constructor body, with the
catch block immediately following it. A function try block
also allows us to throw out of the constructor with a
different exception object than what was initially caught.
But you still don't have an object. You can use function try
blocks to remap the exception, or to treat it as a fatal error
(e.g. by calling abort or exit), but you cannot return normally
from the constructor, and the object that was being constructed
will not exist.
Hi James,
I have produced a crude example that will attempt to
prove otherwise:
# include <iostream>
# include <string>
# include <exception>
struct DataSource {
DataSource( std::string ds )
{
if( ds != "Oracle.driver.foo" )
throw "Could not connect to database";
}
};
class Base
{
private:
DataSource Ds;
public:
Base( std::string );
~Base() { std::cout << "Destructing now...\n"; }
void Print()
{ std::cout << "I am still alive - Please try again.\n"; }
};
Base::Base( std::string ds )
try // function-try block
: Ds( ds ) {}
catch( const char* msg ) {
std::cout << "Exception Caught: \"" << msg << "\"" << '\n';
throw std::exception();
}
int main()
{
Base* B;
try {
B = new Base( "Oracle.driver.bar" );
}
catch( const std::exception& e )
{
B->Print();
delete B;
}
std::cin.get();
return 0;
}
I am interested to hear your, and the groups
thoughts on the validity of such a construct.
:-)
Cheers,
Chris Val