Interactive Bootstraps →“Numbers in detail” →And the implementation

This presumably includes our header, what is the difference between the #include "..." and #include <...> lines? We have used the former on our own header, the latter on a system header, is that it?

This includes the fixed width integer types. Previously we have used int, which is the “most optimal type for the platform”. Usually it is 32-bits, but it is not given. Whereas stdint.h includes types like int8_t, int16_t, int32_t and int64_t, which are defined to be 8, 16 and 32-bits. There are also unsigned counterparts uint8_t, uint16_t, uint32_t and uint64_t.

Unsigned means not negative, so zero or higher.

For reference, if you run the program, you get the following output:

x
00000000: 0100 0000
y
00000000: 3412 0000
z
00000000: ffff ffff
s
00000000: 4865 6c6c 6f2c 2077 6f72 6c64 00
t
00000000: 1a20 4000 0000 0000

Here x, y, z, s and t are just the variables we are dumping, it is the lines below each that are the outputs of this hexdump function.

Ah yes you mentioned that a pointer to a void can be cast to a pointer to a different type. And bytes make a natural unit of length as they are the smallest integer type. And handily two hexadecimal digits make up a byte, with a one hexadecimal unit (4-bit) number being called a nibble.

Here we print the address/offset, but only if the number is divisible by 16 – we use 16 because that is 0x10 in hexadecimal so it’s a round number.

The way we check that a number is divisible by 16 is by checking the first hexadecimal digit (nibble), and making sure it is zero. Compare with checking that a decimal number is divisible by 10, if it ends in a zero, it is.

The way we extract the last nibble, is by using the bitwise operator AND “&”, which goes over each bit in both numbers, and applies the AND operation to it. Let’s have a quick reminder of the bitswise operators, also including OR “|” and XOR (exclusive-or) “^”.

Some notes here, the bitwise AND is also a multiplication for a single bit. And XOR is addition, ignoring the carry, for which AND represents if we have a carry bit.

Another way we could have written “is divisible by 16”, is using the remainder operator, i % 16 == 0, but it is common to use bitwise AND for powers of two.

One last thing is, you note we have actually written (i & 15) == 0, rather than just i & 15 == 0. This is because in C the & actually binds less tightly than == so the latter would be parsed as i & (15 == 0), which would evaluate to i & false and the false would get implicitly cast to 1 so we would end up with i & 1. The order of precedence in C mostly behaves how you expect it (if you remember BIDMAS/BODMAS/BEDMAS/PODMAS, whichever acronym you learnt at school), but the bitwise operators do bind less tightly than equality comparisons so they should be parenthesised. If you aren’t sure you can always add parentheses.

This then prints a space if the number is divisible by two, or in other words, even. Given we start at zero, it prints the initial space after the address/offset too.

And finally printing the actual byte – the %02x prints it in lower-case hexadecimal (0-9, a-f), and pads it to two nibbles using zero if needed.

Then if we have reached the end of a run of sixteen nibbles, or we are on the last number, we print a new line too. The OR operator “||” is logical OR, not bit-wise (remember the bitwise OR is “|”). The difference is two-fold, first the expression “a || b” only cares if either a or b are true (and in C, any non-zero integer, or non-NULL pointer is considered to be true), and the expression “true || b” does not actually evaluate “b” as it already knows the result is going to be true.

Don’t worry, I have covered a lot here, I will keep pointing things out a bit more, so you don’t have to worry about remembering it all in the first place.

Ah finally, some examples for me to play around with.