What could be a reason to not use bracket classes in C++?

Question

It's often needed to accomplish the following task: change the state of something, do action, then change the state back to original. For example, in Win32 GDI it's needed to change background color, then do some drawing, then change the color back.

It can be either done directly:

COLORREF oldColor = SetBkColor( deviceContext, newColor );
drawStuff( deviceContext );
SetBkColor( deviceContext, oldColor );

or via a bracket class that would do the forward change in the constructor and the backward change in the destructor:

CBkColorSwitcher switcher( deviceContext, newColor );
drawStuff( deviceContext );
//once control reaches end of block the switcher is destroyed and the change is reverted

The advantage of a bracket class is obvious - if an exception is thrown in between the changes the change is reverted correctly. What are the disadvantages?

Answer 1

I consider this a best practice. I don't see any disadvantages (except maybe readability?)

Answer 2

This is in fact a well known and widely used C++ idiom known as RAII. Win32 APIs are C APIs and their implementation patterns are different. If you are programming in C++, it is better to handle resource allocation and deallocation using the RAII idiom, by writing thin wrappers on the C API or better re-use existing, well-designed C++ replacements. Java programmers can look upon RAII as a replacement for the finally clause.

Answer 3

One disadvantage is that you usually actually have to define a new class which tends to be a bit of an overhead.

That aside it's (another) very common RAII example and is, in general, a very good approach.

Edit: If, instead of writing a class you just have a function, you can use shared_ptr to execute an arbritary code block on exit from a scope. I think it's probably a bit too cute for most applications though.

Answer 4

A couple of disadvantages, you need to write more code, you end up creating more objects. You have no control over the use of it. Use it wrong and you lose the benefits. e.g.

CBkColorSwitcher * switcher = new CBkColorSwitcher(......)

That said, I think the advantages far outweigh the disadvantages and would prefer the bracket class approach

Answer 5

The disadvantages I see are that (at least in the example you gave):

• It is less clear as to what you are actually doing unless the reader of the code understands the responsibility of the bracket class.
• The cost of creating the bracket class
• Writing the code to implement the bracket class will take longer than a version without it.

Having said this, using RAII is the "correct" way to do this and the benefits far outweigh the disadvantages.

Answer 6

I'm nitpicking here, but:

1. Code size, your code will be bigger because of the exception handler.
2. You need to write a lot of class to handle all sort of switches.
3. Bigger stack.
4. Always preforming code on all exceptions, even if its not need (for example you just want the application to crash)