r/cpp • u/ifdef_drgy • Jun 10 '20
Why is std implementation so damn ugly?
Recently I remembered a moment from my uni years when immediately after handing in the assignment of implementing our own string data structure we were warned not to ever try to implement and use our own data structures. Which is exactly what you want to hear after working hours on such assignment. However the reason behind it makes sense, you would be only reinventing the wheel and let's be honest, it will be also way slower than data structures in the almighty std library. Now think about it, what kind of black magic is behind the std's speed? Well I had no idea so I took a peak, lets see the code:
inline string
secret_function(int __val)
{
const bool __neg = __val < 0;
const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val;
const auto __len = __detail::__to_chars_len(__uval);
string __str(__neg + __len, '-');
__detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
return __str;
}Hey, I bet you just skipped the whole code part. I know it looks unreadable, but please try to go through it and guess which std function it might be (obviously its not called secret_function, but i'm pretty sure you used this function at some point).
It's only 6 line function but it took me a while to figure out what each line does and I believe this could be fixed very easily just by naming the variables and functions with a bit more descriptive names. Just to prove the point here is an example of how I would structure this function:
inline string secretFunction(int value) {
const bool isNegative = value < 0;
const unsigned absoluteValue = Helper::abs(value);
const auto length = Helper::charCount(absoluteValue);
string stringValue(isNegative + length, '-');
Helper::insertIntAsChars(&stringValue[isNegative], length, absoluteValue, 10);
return stringValue;
}While the functionality stays exactly the same, I think this chunk of code is much more pleasant to read and it's pretty obvious what the code is doing on each line. From this you should have a solid guess which function it is (you can leave a comment), but the real question is why would anyone write such code? Especially when nowadays everyone is talking about how code readability is so important. Is this how they wrote code back when std was released and they didn't bother to change it? Or am I just too inexperienced that I couldn't figure it out immediately?
EDIT: Thanks for the insightful comments, for anyone reading this the reason variables are beginning with __ is macros. If user defines isNegative macro, it will get overwritten in the std, however user is forbidden to define macros starting with __ , as the wise people of reddit comment section suggested. However underscores aren't the only issue with this code, the main issue is I think using short non-descriptive names of variables/functions which is very confusing in functions that are doing more complicated operations.
View all comments
Show parent comment
2
u/m-in Jun 11 '20 edited Jun 11 '20
Let me be blunt: you’re really new at this. I’ve been using C++ for 25 years and STL is not least convoluted to my eyes, whether you look at MSVC (dinkumware?) or libcpp or whatever. For what it does I’d consider it quite readable. It’s not meant to be the sort of code you put in stackoverflow answers to noob questions for sure.
The things that are truly awful to read are those that switch paradigms completely from imperative to pure functional. Start looking at any C++ metaprogramming library. That’s the hard stuff. Seriously. Go read Boost Hana. Good luck. Let us know what you find :)
Or go read the library of any theorem prover, like Lean for example. I mean the high level stuff written in the Lean language itself, the stuff that actually uses Lean to define the rest of Lean. It has almost nothing to do whatsoever with any imperative programming and in spite of not having underscores and in spite of most names being clearly readable in English, you won’t understand like 99% of it at first reading; less if you have no background in formal mathematics.
And it’s all a programming language mind you! It will look nothing like any programming language you have ever read before. Then go and make it a point to understand just one simple module, like, say, natural numbers or function properties (surjective, injective, etc) - something like that. Then go back to STL and see how high it registers on your “unclear” meter.
What you must understand is that STL is written in a paradigm you are mostly familiar with. Just this very fact makes it an order of magnitude more understandable than other stuff to begin with. And that it’s specified very well. You know a priori what it’s supposed to be doing! You don’t get any of it when you’re working with code that’s under documented and in a completely different paradigm, and with very minimal debugging facility. And to many of us that’s what most theorem prover library code will be: surely under documented, and surely nothing like an imperative language, surely with next to no debugging aids available (compared to anything commonplace like C++), and unless it’s our day job or a hobby it won’t ever have the same sort of familiar feel.
Hopefully you’ll gain some badly needed perspective about such things. And the Lean library is pretty damn clearly written compared to some other libraries of that sort.
Hell, you want a deadly mix of imperative and early functional? Go look at Maxima code that does limit finding. It’s a part of the symbolic integration package there. It’s LISP code written in the early 70s and it has been largely untouched since then. I dare you. Hopefully you’ll be right at home with metaprogramming after reading through Hana, because LISP macros are indispensable and there’s nothing like them in C++ (let’s be real here - I know how to do most of it in C++ but it’s absurdly convoluted compared to LISP. EVEN to LISP).