This is a series of things that I found out when learning C++. The approach is going to non-standard and likely to annoy any normal C++ professional. I am interested in languages in general and so I will be doing all my early code without and STL at all. I want to learn what features the language offers before starting to use the standard libraries. To this end I try to do do simple version of the features that are already available. That way I can see how these features are implemented in the standard libraries. To me that feels like a important advantage in learning the language. I did try to read the code for the libraries but it has a lot of very nuanced code that I will only get to understand much later on. The code is still interesting to step through however as it does offer clues as to how to unpick various implementations.
Coding Environment
I will be using Visual Studio for the editor, compiler and debugger. I did try Visual Studio Code for a while including using it to look at Rust. However I find that while VS is bloated and has bugs etc, it is has the easiest entry into starting to code.
I was going to picking C++ 11 as the baseline, but VS starts with 14 as a default so I will go with that.
I have found one thing from C++ 17 that I would like which is the “if constexpr
” as this allows for compile time code removal. Without this in the example below, the compiler needs to be told to ignore any warnings from the other code path.
if constexpr ( is_same_v<key_t, const char*> )
{
hashable = (uint32_t)key[0];
}
else
{
hashable = (uint32_t)key;
}
Learning by stepping through the STL implementation
Visual Studio STL implementation can be found here:
C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC
So you can go there to read the code. It is also possible to step through the STL code. Note that Visual Studio setting default to always stepping over this code. To change this go to the menu Debug -> Settings
and turn off the setting Enable Just My Code
.

This can be very instructive in seeing how these things are designed. An example is that I saw that unordered_map with the std::string will take a deep copy of the chars when it is storing them in the key an values pairs. I also go to see the type of allocators that are used by default.
Be warned, as the code looks complex as it has all the support for all the compiler versions. This makes the code look very cluttered and hard to read but focusing on where the code goes can help with understanding it.
The IDE settings have grown over this process, so I have a full page dedicated to the setting from the default. See:
Speed of Learning
This methodology, does mean I have to go very slowly, trying to understand each part of an implementation. I am not that quick a coder in the first place so this is a long process. I don’t mind as I am enjoying the journey. I am using the Internet as my manual and user guide and am very happy to find the answers out there rather than just randomly trying solutions. Do this, however, has the effect that sometimes something I learn does not stick. This is also one of the motivations to doing these posts. It will allow me to capture the coding patterns rather than having to commit them to memory.
Annoying Stack Overflow
I have a number of interesting web sites that help this journey (see below), but obviously Stack Overflow is an important resource. Interestingly, as I learn I find that some answers out there, while correct, may not be what you are looking for. So it is important to keep in mind your real use case when reading Stack Overflow. There is also a lot of historical answers out the and not only has the language moved on to provide better solutions but also the accepted thinking has moved on as well.
I did try asking a question and found that they seem to want code that does not work so they can show how to fix it. I put three solutions to a problem to ask which of them was the preferred idiom in C++ and was told that working code should be submitted on Stack Exchange. So I posted there as well and was told to put the code on Stack Overflow. Humm.
I did get some very good answers and a lot of patience from one particular contributor, so I owe a lot to them – thanks. I jump in and did not know the acceptable protocol when submitting there.
Here is a list of things I found from posting just two questions:
- Try to post a very small thing with a very specific question. And with broken code if possible.
- Don’t expect them to reply with a solution that is just in C++. If an STL function will do the job they will consider that the answer. This is hard if you have a bigger problem that is hard to reduce down to a small example that is then not trivial enough to be solved with one library call.
- The comments section is very limited and not really to be used for chat or interactive discussion.
- There is a chat system but you have to have enough points to use it. These are gained by up votes.
- If you post a question they don’t like or your have not explained it well enough it will be down voted and you lose points.
- They have an expected style guide that you should conform to. If you don’t then the answers will all be about fixing that. I would suggest K&R brackets and one of the standard variable formats (
m_member, first_entry
etc).- Don’t use
_variable_name
as this this had a lot of discussion already and the outcome is to not use it anywhere even if it is legal.
- Don’t use
In retrospect it is a bit obvious that I should have read the tour and read the FAQ.
Bit Fields
So what is wrong with the 8 byte packed structure below?
struct meta
{
char twoCC[2];
bool isStack : 1;
bool isPowerOf2 : 1;
bool isBlocks : 1;
bool isStatic : 1;
bool isFreed : 1;
int padding : 3;
size_t twoByteIndex : 16;
uint8_t powerOf2Index;
uint16_t size;
};
Times Up!
Changing type in the list will trigger an alignment.
While there is support added for bool
in C++ other ‘integer types’ are not supported, and you certainly cant go over 8 bits. I liked the idea of keeping the type, so the code that used it would be OK when assigning, and having the size be smaller than its default, but that is a step to far.
struct meta
{
char twoCC[2];
bool isStack : 1;
bool isPowerOf2 : 1;
bool isBlocks : 1;
bool isStatic : 1;
bool isFreed : 1;
bool padding1 : 1;
bool padding2 : 1;
bool padding3 : 1;
uint16_t twoBytIndex;
uint8_t powerOf2Index;
uint16_t size;
};
Pre and Post Increment and the operator++
There is a mantra that is ‘learn to do pre-increment because it is better’. Well that is hard for those that were taught in the old days when this was not a thing. I finally heard a good explanation why… This is about performance and what is returned from the operator. All C statements return a value, even if it is not used.
int i = 1;
i++;
The second line will evaluate to 2, but then be thrown away.
int i = 1;
++i;
This second line will return the original value of i (the value 1) but internally do the work to increment the value of i. This would not normally be an issue as the compiler will optimise any extra work away. But! What about a class where the increment operator has to be either the pre or post increment type. For the post increment the code will have to return a new value and that could incur the cost of the ctor and copy. Where as the pre increment can return the original value/class and hence have no cost.
Hence the rule of ‘do pre increment’ as a general rule is good as you can get into the habit of it.
There is an extra part to this that needs some care too. Example taken from Visual Studio Documentation
// Prefix increment operator.
Point& Point::operator++()
{
_x++;
_y++;
return *this; // Compiler can optimise
}
// Postfix increment operator.
// int is required but ignored.
Point Point::operator++(int)
{
Point temp = *this;
++*this;
return temp; // May create a copy it can't optimise
}
Links
- Learn CPP:
- CPP Reference:
https://en.cppreference.com
- Note that it will sometimes have a “Possible implementation”. This is very useful to see the true idea behind the function. For a very simple example see:
- Bit Twiddling Hacks:
Mark is doing a full time job but likes to have side projects. Currently learning C++ and Vulkan. Other areas of interest are photography and going for long walks.