Code reading: where can I read great, modern, and well-documented C++ code?

Question

Reading code is one of the best ways to learn new idioms, tricks, and techniques.

Sadly it's very common to find badly written C++ code. Some use C++ as if it was C, others as if it was Java, some just shoot in their feet.

I believe gtkmm is a good example of C++ design, but a binding could not be the best code to read (you need to know the C library behind it).

Boost libraries (at least the one I read) tend to be less readable than I'd like.

Can you mention open source projects (or other projects which source is freely readable) that are good example of readable, modern, well-documented, and auto-contained, C++ code to learn from?

(I believe that one project per answer will be better, and I'd include the motivation that led you to selecting that one.)

EDIT: The question was not intended from a newbie point of view (even if good readings for newbies are welcome, I don't believe that it should make any difference). The reading issue with boost is primarly, as noted in comments, that it's filled with compiler dependent workarounds that make its prose less fluent.

EDIT2: It was not my intention to dismiss all the boost libraries. It's just that trying to read, as an example, the BGL I didn't found the prose I was searching for (even if you can eventually understand them). If you have better examples from boost just point to the specific library.

Answer 1

QT is very well documented and has a nice and elegant design.

Answer 2

I see that you've already decided that Boost is "less readable than [you'd] like", but Boost is quite possibly the best example of exactly the kind of source code you're looking for. The unfortunate fact is that in spite of all of its positive characteristics, C++ itself is less readable than you'd like.

The more time you spend reading Boost code, the more C++ you'll understand and the more readable it all becomes.

At the op's suggestion, here are some libraries I think are pretty good:

• smart_ptr - small, pretty self-contained, and idiomatic. Might be a good starting place.
• pool - more complicated than smart_ptr, but still fairly portable and idiomatic.
• filesystem - also sort of "medium" complexity, not terribly portable, but very useful and intuitive
• iostreams - large, complicated, many patterns, lots of platform-specific things
• asio - also large, complicated, and not portable.

There are many more to choose from.

One of the things that makes Boost good, and still readable, is that most of its libraries consistently factor out the platform/compiler-specific tweaks and leave the primary functionality as portable as possible. It's a really, really great thing for C++ devs to learn.

Note: when I say "portable" or "not portable" above, I'm not talking about the library as a whole, but rather the underlying implementation that a reader would be looking at. In other words, "not portable" means lots of implementation details that are particular to a platform. Boost libraries are amazingly portable in practice; I don't want to be misunderstood.

Answer 3

You could have a look at:

• dlib
• Some Google C++ projects, like Protocol Buffers
• Ogre3D

Some projects NOT to learn from:

• QT ("C-with-classes", not modern C++)
• wxWidgets (Quite old, has its own string class).

Also I wouldn't recommend reading the Boost code if you are a C++ newbie, you will get buried in little details.

Answer 4

In my humble opinion I think dlib has some of the most readable code around. Modern style, RAII, no pointers, religious use of contract programming, etc.

But I maybe biased as I run this particular open source project :)

Answer 5

Another well-written C++ project is the Monotone version control system.

Answer 6

I've played around some with Google Test (Google's C++ unit testing framework) and have been impressed with its clean design and clarity of code. It's also interesting to me how Google Test's adherence to the Google C++ Style Guide enhances its readability (even though I don't always agree with the Google C++ Style Guide).

I would expect other notable C++ projects from Google, such as Chromium (the codebase for Google Chrome) and Protocol Buffers, to be similarly high quality.

Answer 7

http://www.virtualbox.org - mostly because it's a complete,complex and large application(s) - and not "just" a library.

I'd learned a lot from the source code of http://code.google.com/p/protobuf/ as well.

Answer 8

I'm surprised nobody mentioned Loki

Answer 9

I would say: if the code is beautiful, easy to read, modern, portable and uses latest goodies of C++, then probably you are reading textbook...

Unfortunately most of modern code is not so easy to read and far from being beautiful... Because real life is quite hard.

Examples of greatest modern software libraries that extremely useful and good designed Boost and C++.

• Boost - includes lots of ifdefs for each broken compiler and to work well on many broken OS platforms.
• Boost - some libraries push template meta-programming to limit in order to get as much flexibility as possible but readability suffers!
• Qt - very well designed modern, very useful library (even some people think that if library does not push to limit all templates stuff it is not true C++) but... it requires to run on even very old and odd compilers... So you will find many oddities like not using dynamic_cast or other stuff. But it is great, well debugged high quality software.

Bottom line, programming is hard. Take a look on this code I had written. It is code of cache system with invalidation, triggers, LRU and timeout support, that can be shared between forked processes and normal threads... But it is damn hard to read and understand. But is very valuable piece of software to me that required lots of writing.

(And it is uses STL, smart pointer, allocators, RAII and many other goodies)

P.S.: I do not recommend to learn from my code ;-)

Answer 10

I think ACE is a good example of a mature open-source multi-platform C++ library with a lot of available documentation. A lot of the documentation is in the form of academic papers, so you learn a lot about the underlying algorithms, design patterns, and tradeoffs.

However, note that it originated some time ago, and suffers from some ugliness in order to be compatible with all the C++ compilers it has ever supported. So it may not fit your desire for "modern" C++ code.