Correct way to initialize an object with exception throwing constructor

Question

Hi,

This seems to be a trivial question but I got hung on it for a few hours now (maybe too much Java killed my C++ braincells).

I have created a class that has the following constructor (i.e. no default constructor)

VACaptureSource::VACaptureSource( std::string inputType, std::string inputLocation ) {
    if( type == "" || location == "" ) {
 throw std::invalid_argument("Empty type or location in VACaptureSource()");
}
type = inputType;
location = inputLocation;

// Open the given media source using the appropriate OpenCV function.
if( type.compare("image") ) {
 frame = cvLoadImage( location.c_str() );
 if( !frame ) {
  throw std::runtime_error("error opening file");
 }
}
else {
 throw std::invalid_argument("Unknown input type in VACaptureSource()");
}

}

When I want to create an instance, I use

    // Create input data object
try {
 VACaptureSource input = VACaptureSource("image", "/home/cuneyt/workspace/testmedia/face_images/jhumpa_1.jpg");
}
catch( invalid_argument& ia ) {
 cerr << "FD Error: " << ia.what() << endl;
 usage(argv[0]);
}
catch( runtime_error& re ) {
 cerr << "FD Error: " << re.what() << endl;
 usage(argv[0]);
}

However, in this case the instance is local to this block and I can't refer to it anywhere else. On the other hand, I can't say

VACAptureSource input;

at the beginning of the program since there's no default constructor.

What is the correct way to do this?

Thanks!

Answer 1

A local variable is scoped to the block in which it's allocated (like Java) but it'll destruct as soon as the block ends (unlike Java) so you should either do all the stuff you want in the try block itself (which might not be desirable if you want to only handle constructor exceptions) or you should allocate the object somewhere else (e.g. heap) and use a pointer in the parent block to access it.

Answer 2

What about using a pointer (or some RAII version thereof)?

VACaptureSource* input = NULL;

try {
    input = new VACaptureSource(...);
} catch(...) {
    //error handling
}

//And, of course, at the end of the program
delete input;

Answer 3

You may use a pointer

VACaptureSource* input;
// Create input data object
try {
    input = new VACaptureSource("image", "/home/cuneyt/workspace/testmedia/face_images/jhumpa_1.jpg");
}
catch( invalid_argument& ia ) {
    cerr << "FD Error: " << ia.what() << endl;
    usage(argv[0]);
}
catch( runtime_error& re ) {
    cerr << "FD Error: " << re.what() << endl;
    usage(argv[0]);
}

And you need to free the object when you finish to use it

delete input

Answer 4

why do you need to refer to it outside the try block?

Instead of

try {
  VACaptureSource input = VACaptureSource("image", "/home/cuneyt/workspace/testmedia/face_images/jhumpa_1.jpg");
}
//catch....

//do stuff with input

you could move everything into the try block:

try {
  VACaptureSource input = VACaptureSource("image", "/home/cuneyt/workspace/testmedia/face_images/jhumpa_1.jpg");
  //do stuff with input
}
//catch....

or you could factor it out into a separate function, which is called from the try block:

void doStuff(VACaptureSource& input){
  //do stuff with input
}

try {
  VACaptureSource input = VACaptureSource("image", "/home/cuneyt/workspace/testmedia/face_images/jhumpa_1.jpg");
  doStuff(input);
}
//catch....

The last one even gives you the nice bonus of separating the construction from use, which places nicely into unit tests where you might want the function to work on a mock object instead.

Answer 5

What about adding a default constructor which leaves the object in a special unconfigured state? Then have an create() function for actually creating it.

Then you can do:

VACaptureSource input;
try
{
   input.create("image", "...");
}
catch(...)
{
   ...
}

Depending on the situation this might be better than messing with pointers. Although then you also have to check if the create() was actually called before doing something...

Answer 6

I don't actually see any probelms here:

A couple of things I would update:

• Catch exceptions by const reference.
• The compiler may optimize away the copy construction in your code
  But it looks neater without it. Just declare input with its parameters.
• I would refactor the constructor to take const reference parameters
  And I would initialise them in the initialiser list.
• Also I would make sure the member 'frame' is actually a smart pointer.

So I would do this (for clarity).

VACaptureSource::VACaptureSource( std::string const& inputType,
                                  std::string const& inputLocation )
      :type(inputType)
      ,location(inputLocation)
{
    // Other Code that throws.
}
void playWithCode()
{
    // Get input information from user.
    VACaptureSource input("image", "/home/cuneyt/workspace/testmedia/face_images/jhumpa_1.jpg");

    // use the input object.
    // Do not need to play with pointers here.
}
int main()
{
    try
    {
        playWithCode();
    }
    catch( invalid_argument const& ia )
    {    cerr << "FD Error: " << ia.what() << endl;
         usage(argv[0]);
    }
    catch( runtime_error const& re )
    {    cerr << "FD Error: " << re.what() << endl;
         usage(argv[0]);
    }
}

Answer 7

Can I just observe that just about any but the most trivial constructor can be expected to throw an exception. You should therefore not consider exceptions to be "special" in some sense, but instead write your code so that it deals with them naturally. This means using RAII, and the other techniques that other answers here have suggested.

Answer 8

Simple. Don't throw exceptions within a constructor. Not only do you have to wrap the constructor in the try block, you won't be able to handle memory very well in the event you catch an exception (do you call the destructor? how much of the class's memory needs to be deleted?)

UPDATE0: Although, I'm not sure if memory management is a problem if you're using an instance.

UPDATE1: Hmmm, maybe I'm thinking about exceptions in destructors.

int
main2(int argc, char* argv[])
{
  MyClass class;
  class.doSomething();
}

int
main(int argc, char* argv[])
{
  int result = 0;
    try {
      main2(argc, argv);
    } catch (std::exception& se) {
      // oh noes!
       result = 1;
    }
  return result;
}

Answer 9

I can't say

VACaptureSource input;

at the beginning of the program since there's no default constructor.

There is a good reason you didn't create a default constructor: namely that a VACaptureSource only makes sense when associated with a file. So don't create a default constructor. Instead simply recognize that the scope of the VACaptureSource object is the try block, and use it inside there.