7

After many years of coding scientific software in C++, I still can't seem to get used to exceptions and I've no idea when I should use them. I know that using them for controlling program flow is a big no-no, but otherwise than that... consider the following example (excerpt from a class that represents an image mask and lets the user add areas to it as polygons):

class ImageMask
{
public:
    ImageMask() {}
    ImageMask(const Size2DI &imgSize);

    void addPolygon(const PolygonI &polygon);

protected:
    Size2DI imgSize_;
    std::vector<PolygonI> polygons_;
};

The default constructor for this class creates a useless instance, with an undefined image size. I don't want the user to be able to add polygons to such an object. But I'm not sure how to handle that situation. When the size is undefined, and addPolygon() is called, should I:

  1. Silently return,
  2. assert(imgSize_.valid) to detect violations in code using this class and fix them before a release,
  3. throw an exception?

Most of the time I go either with 1) or 2) (depending on my mood), because it seems to me exceptions are costly, messy and simply overkill for such a simple scenario. Some insight please?

Improve this question
16
  • 4
    Prevent default construction ? Prevents invalid ImageMask instances being created. Commented Jul 13, 2012 at 13:07
  • 1
    Why do you need a default constructor? Commented Jul 13, 2012 at 13:08
  • 4
    You should throw an exception; it doesn't matter if exceptions are costly if you have a flaw in your program that needs to be fixed. You shouldn't silently return because that hides the error, and you shouldn't do an assert because those are compiled out in release mode compilations, and also the client of this class shouldn't need to know what imgSize_.valid is since it's an implementation detail. Commented Jul 13, 2012 at 13:12
  • 3
    @MadScientist: no STL containers in C++11 require that your type is DefaultConstructible. Commented Jul 13, 2012 at 13:13
  • 1
    When you say exceptions are "costly, messy, and simply overkill", are you sure they are more costly and messy than whatever other mechanism you propose for handling errors? Commented Jul 13, 2012 at 13:20

4 Answers 4

Reset to default
6

The general rule is that you throw an exception when you cannot perform the desired operation. So in your case, yes, it does make sense to throw an exception when addPolygon is called and the size is undefined or inconsistent.

Silently returning is almost always the wrong thing to do. assert is not a good error-handling technique (it is more of a design/documentation technique).

However, in your case a redesign of the interface to make an error condition impossible or unlikely may be better. For example, something like this:

class ImageMask
{
public:
    // Constructor requires collection of polygons and size.
    // Neither can be changed after construction.
    ImageMask(std::vector<PolygonI>& polygons, size_t size);
}

or like this

class ImageMask
{
public:
    class Builder
    {
    public:
        Builder();
        void addPolygon();
    };

    ImageMask(const Builder& builder);
}

// used like this
ImageMask::Builder builder;
builder.addPolygon(polyA);
builder.addPolygon(polyB);
ImageMask mask(builder);
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2

I would try to avoid any situation where it's possible to create data that is in some kind of useless state. If you need a polygon that is not empty, than don't let empty polygons be created and you save yourself much trouble because the compiler will enforce that there are no empty polygons.

I never use silent returns, because they hide bugs and this makes finding bugs much more complicated than it have to be.

I use asserts when I detect that the program is in a state that it only can be in, if there is a bug in the software. In your example, if you check in the c'tor that takes a Size2DI, that this size is not empty, than asserting if the size stored is not empty, is useful to detect bugs. Asserts should not have side effect and it must be possible to remove them, without changing the behavior of the software. I find them very useful, to find my own bugs and to document, the current state of the object / function etc.

If it's very likely, that a runtime error will be handled directly by a caller of a function, I would use conventional return values. If it's very likely, that this error situation have to be communicated over several function calls at the call stack, I prefer exceptions. In doubt I offer two function.

kind regards Torsten

Improve this answer

Comments

1

To me, 1 is a no option. Whether it is 2 or 3 depends on the design of your program/library, whether you consider (and document) default-constructing image mask and then adding polygons a valid or invalid usage of your component. This is an important design decision. I recommend reading this article by Matthew Wilson.

Note that you have more options:

  • Invent your own assert that always calls std::terminate and does additional logging
  • Disable the default constructor (as others already pointed out) -- this is my favourite
Improve this answer

Comments

1
  1. "Silently return" - that's real 'the big no-no'. The program should know what's wrong.
  2. "assert" - the second rule is that asserts using only if normal program's flow couldn't be restored.
  3. "throw exception" - yes, this right and good technique. Just take care about exception-safety. There are many articles about exception-safe coding on GotW.

Don't afraid exceptions. They don't bite. :) If you'll take this technique enough, you'll be a strong coder. ;)

Improve this answer

2 Comments

Funny that exceptions are so easy and normal to use under Java, while with C++ they are so misunderstood
Nothing to be surprised. Java manages your memory by itself; Cpp-developer can (and fortunately or unfortunately - must) manage his memory by his-brains. ;)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.