Is there a readable implementation of the STL? [closed]

Answer 1

Well, the STL is pretty complicated, so I think there's a certain amount of essential complexity going on here. It's not surprising that it may seem a little bewildering at first glance.

That said, maybe you could check out Borland's STLport and see if you find that an easier read.

Answer 2

Note that GCC's STL headers have the tab stop set to eight. Reconfigure your editor or replace tabs with eight spaces and it should be much more readable.

Answer 3

Two key points stand out:

1. No implementation of the STL is readable without an understanding of the goals, rationale, benefits and limitations of the language itself, and general approach.
2. Most implementations are readable once you have a deep understanding of (1) because the code is self-documenting on those premises. You might not like the formatting, but that really should be the least of your problems.

As a side note, you might have more success with the MSVC version because it's not trying to target multiple as many compilers. Compiler bugs and implementation-defined behavior result in various subtle workarounds. As those workarounds grow in number (as certainly happens when you add more compilers), the code can get gross fast.

Answer 4

RDESTL provides a 'small subset of STL functionality' (but also has some extras). I personally found the code quite instructive and easier to navigate than the big guys like STLPort or Dinkumware's implementation that ships with VC++.

Answer 5

I use the The C++ Standard Library: A Tutorial and Reference and can highly recommend it. Of course it is not something you read cover-to-cover, but is an very handy reference. Check out the reviews on Amazon as well.

Answer 6

Yes, there is original implementation of the STL by Alexander Stepanov and Meng Lee. It is the most readable STL implementation I have ever seen. You can download it from here.

Below is an implementation of pair. Note how readable the source code really was:

#include <bool.h>

template <class T1, class T2>
struct pair {
    T1 first;
    T2 second;
    pair() {}
    pair(const T1& a, const T2& b) : first(a), second(b) {}
};

template <class T1, class T2>
inline bool operator==(const pair<T1, T2>& x, const pair<T1, T2>& y) { 
    return x.first == y.first && x.second == y.second; 
}

template <class T1, class T2>
inline bool operator<(const pair<T1, T2>& x, const pair<T1, T2>& y) { 
    return x.first < y.first || (!(y.first < x.first) && x.second < y.second); 
}

template <class T1, class T2>
inline pair<T1, T2> make_pair(const T1& x, const T2& y) {
    return pair<T1, T2>(x, y);
}

Back to the roots!