Alex Rivera | Logout

Using strong typedef as a more lightweight alternative to Boost Parameter library?

Asked 2012-02-09T12:55:05.203
16

I often use the Boost strong typedef utility to improve the safety of my programs. For example by writing code like this:

BOOST_STRONG_TYPEDEF(int, X)
BOOST_STRONG_TYPEDEF(int, Y)
BOOST_STRONG_TYPEDEF(int, Width)
BOOST_STRONG_TYPEDEF(int, Height)

struct Rect {
    Rect(X x, Y y, Width w, Height h);
};

// Usage:
Rect rect(X(10), Y(20), Width(800), Height(600));

The strong typedef here improves both code readability and safety. (The compiler will report an error if the arguments are provided in the wrong order, which would not have been the case if the arguments were all int.)

My questions are:

  • Is it ok to use BOOST_STRONG_TYPEDEF for this purpose? (The documentation is very brief.)
  • Are there important reasons to prefer the boost parameter library instead?
c++ boost boost-parameter
Edit
Report

1 Answer

2

Using BOOST_STRONG_TYPDEF is creating a new type, where as the boost parameter library is for giving names to parameters. It lets you be more explicit with what your functions take. For example (from the boost documentation)

#include <boost/parameter/preprocessor.hpp>

namespace graphs
{
  BOOST_PARAMETER_FUNCTION(
      (void),                // 1. parenthesized return type
      depth_first_search,    // 2. name of the function template

      tag,                   // 3. namespace of tag types

      (required (graph, *) ) // 4. one required parameter, and

      (optional              //    four optional parameters, with defaults
        (visitor,           *, boost::dfs_visitor<>())
        (root_vertex,       *, *vertices(graph).first)
        (index_map,         *, get(boost::vertex_index,graph))
        (in_out(color_map), *,
          default_color_map(num_vertices(graph), index_map) )
      )
  )
  {
      // ... body of function goes here...
      // use graph, visitor, index_map, and color_map
  }
}

Lets you explicitly say what is expected, almost in a design by contract sort of way. However I find this complicates the readability of your code enough to make it not worth doing.

Personally I prefer to use BOOST_STRONG_TYPEDEF as it creates a new types "that can be used for matching either function or template parameters" (again from the boost documentation).

answered 2012-02-09T13:09:56.577

Your Answer