The other day, I talked to a C++ developer, who is relatively new in the language, about the C++ training they just had at his company. The training topics were already somewhat advanced and contained e.g. STL containers and their peculiarities, STL algorithms and some boost stuff like binders and smart pointers. That got me thinking about how much of STL and boost does a C++ developer just has to know in order to survive their C++ projects.
There is also another angle to this. There are certain corners of the C++ language, e.g. template metaprogramming, which are just hard to get, even for more experienced developers. And because of that, in my opinion, they have no place in a standard industry C++ project. But where do you draw the line? With template meta-programming it is obvious that it probably will never be in every day usage by Joe Developer. But what about e.g. boost’s multi-index container or their functional programming stuff? One could say that it depends on the skills of team whether more advanced stuff can be used or not. But suppose your team consist largely of C++ beginners and does not have much experience in the language, would you want to pass on using Boost.Spirit when you had to do some serious parsing? Or would you want to use error codes instead of decent exceptions, because they add a lot more potentially “invisible” code paths? Probably not, but those are certainly no easy decisions.
One of the problems with STL and boost for a C++ beginner can be illustrated with the following easy problem: How do you convert an int into a std::string and back? Having already internalized the stream classes the beginner might come up with something like this:
int i = 5; std::ostringstream out; out << i; std::string i_string = out.str(); int j=0; std::istringstream in(i_string); in >> j; assert(i == j);
But if he just had learned a little boost he would know that, in fact, it is as easy as this:
int i=5; std::string i_string = boost::lexical_cast<std::string>(i); int j = boost::lexical_cast<int>(i_string);
So you just have to know some basic boost stuff in order to write fairly decent C++ code. Besides boost::lexical_cast, which is part of the Boost Conversion Library, here is my personal list of mandatory boost knowledge:
Boost.Assign: Why still bother with
std::map::push_back and the likes, if there is a much easier and concise syntax to initialize containers?
Boost.Bind (If you use functional programming): No one should be forced to wade through the mud of STL binders any longer. Boost::bind is just so much easier.
Boost.Foreach: Every for-loop becomes a code-smell after your first use of BOOST_FOREACH.
Boost.Member Function: see Boost.Bind
Boost.Smart Pointers: No comment is needed on that one.
As you can see, these are only the most basic libraries. Other extremely useful things for day-to-day programming are e.g. Boost.FileSystem, Boost.DateTime, Boost.Exceptions, Boost.Format, Boost.Unordered and Boost.Utilities.
Of course, you don’t have to memorize every part of the boost libraries, but boost.org should in any case be the first address to look for a solution to your daily C++ challenges.
5 thoughts on “How much boost does a C++ newbie need?”
I really would like to meet Joe Developer. As he is cited very often, I guess he must be really important. 😉
Apparently you don’t need to know c++ either. Wtf is std::map::push_back?
You got me! Of course that should be std::map::insert. See, that proves exactly my point about boost::assign 😉
Funny thing is, the stringstreams are actually more optimal/faster than boost::lexical_cast for string conversion so in this case the beginner wins 😛
AFAIK the performance issues of lexical_cast have been solved some time ago. And even if it was slower than stringstream, I would still prefer lexical_cast because it is way easier to write and read.