How to add error checking in a class member function? - c++

Question

Given a class and one of its member functions like this:
// constructor
class Stitcher::Stitcher(const std::vector<cv::Mat> imgs)
{
calibrate(imgs);
}
// one of its member functions that gets called upon construction
void Stitcher::calibrate(const std::vector<cv::Mat> imgs)
{
// Do some stuff here
}
When constructing this Stitcher object, it runs the calibrate function upon construction. However calibrate will sometimes fail and I need a way to handle such failures. I was thinking of returning a boolean but wasn't sure how to do that because I still need access to the Stitcher object for other member functions. Basically I am instantiating it like this currently: Stitcher stitcher(images); which works fine as long as it doesn't fail. Then I can use stitcher.stitch(), stitcher.otherFunction(), etc. Any suggestions for this C++ newbie on how to handle errors inside a class member function?

Answer 1

There is a RAII (Resource Acquisition Is Initialization) idiom which is highly recommended in C++. One of the aspects of the RAII is the idea that there should not exist badly constructed or uninitialized objects. From your question I conclude that you are trying to initialize the object, but sometimes that is impossible. That is the application of RAII.
In C++ constructor functions don't return error codes, so there is another technique to handle errors: exceptions. In brief exception thrown from the constructor don't allow you to leave the not-constructed-yet object in a partially constructed state.
class Stitcher {
public:
Stitcher(const std::vector<cv::Mat> &imgs) {
calibrate(imgs);
// If the calibrate method fails, the object is not being constructed.
// The next line will not be executed on a non-calibrated object:
doSmthWithCalibratedImgs(imgs);
}
private:
void calibrate(const std::vector<cv::Mat> &imgs) {
// Do some stuff here
// if cannot calibrate:
throw exception("Cannot calibrate");
}
};
So the next task would be to handle possible exceptions from the code that constructs Stitcher objects.
Note that I've changed the signature of the methods to pass the vector by const reference: I guess that is what you need. Another thing that you might need is to store the imgs vector inside of the object as a data member, but that depends on the task and is up to you.

Answer 2

What you could do is throw an exception to indicate a problem that occurs during the execution of your program. The standard library has a number of exception classes that you could use for throwing an exception, all of which derive from std:exception. For example, std::out_of_range.
To throw a standard exception you create a string that describes the exception and use it to initialise the exception object:
std::string s("my exception")
...
throw std::out_of_range(s);
You can also write:
throw std::out_of_range("out of from somewhere");
using implicit conversion from char* to std::string.
Another possibility is to define your own special exception class, derived directly or indirectly from std::exception. However, you have to provide the overridden virtual function what() in your class:
class MyException: public std::exception
{
public:
MyException(...){
}
virtual const char* what() const throw() {
return "C++ Exception";
}
};
Another way to provide the what() function is to derive your exception class from one of the classes that have a string constructor for the what() argument:
class MyException: public std::out_of_range
{
public:
MyException(const std::string &what): std::out_of_range(what) {}
};
Like this you can different classes for different types of exceptions.
Now can you throw an exception in Stitcher::calibrate() but you have to have try...catch block to catch it. Something like this:
try
{
Stitcher stitcher;
// this will be executed if no exception is thrown
}
catch (const std::exception &e)
{
std::cout << e.what();
}

Answer 3

The first question you have to answer is (regarding your business logic): should failure of calibrate(imgs) also imply failure of constructing object of type Stitcher.
1. Possibility:
calibrate(imgs) fails, but the object is constructed. You would need some member methods (something like isCalibrated(..), recalibrate()... etc.), to be able to query object if the calibration was succesful, and maybe try to recalibrate if the predonditions are met at some other time, etc.
2. Possibility:
Stitcher constructor postcondition is, that calibration was successful. In this case, you can't tolerate the failure, so you have to throw exception within constructor.
Regarding this, you will maybe have to decide, what kind of exception safty guarantee you would aim to offer.
You have 3 choices here:
i) strong exception safety guarantee (best choice, if possible)
ii) basic exception safety gurantee (second best choice)
iii) no exception safety guarantee (worst choice)
Basically, doing work in the constructor is not a good practice. You could consider constructig Stitcher by setting up the required data members in the contructor and meet all necessary preconditions, and then provide some member methods like for ex. Calibrate()-with return false by failure, TryCalibrate()-which throws exception, etc., so the clients of Stitcher have better control about failure handling.