it-ebooks - Learn C The Hard Way

Let's get familiar with more things you can do with variables by declaring various ints, floats, chars, and doubles. We'll then use these in various math expressions so you get introduced to C's basic math.

Here's what's going on in this little bit of nonsense:

ex7.c:1-4

The usual start of a C program.

ex7.c:5-6

Declare an int and double for some fake bug data.

ex7.c:8-9

Print out those two, so nothing new here.

ex7.c:11

Declare a huge number using a new type long for storing big numbers.

ex7.c:12-13

Print out that number using %ld which adds a modifier to the usual %d. Adding 'l' (the letter ell) means "print this as a long decimal".

ex7.c:15-17

Just more math and printing.

ex7.c:19-21

Craft up a depiction of your bug rate compared to the bugs in the universe, which is a completely inaccurate calculation. It's so small though that we have to use %e to print it in scientific notation.

ex7.c:24

Make a character, with a special syntax '\0' which creates a 'nul byte' character. This is effectively the number 0.

ex7.c:25

Multiply bugs by this character, which produces 0 for how much you should care. This demonstrates an ugly hack you find sometimes.

ex7.c:26-27

Print that out, and notice I've got a %% (two percent chars) so I can print a '%' (percent) character.

ex7.c:28-30

The end of the main function.

This bit of source is entirely just an exercise, and demonstrates how some math works. At the end, it also demonstrates something you see in C, but not in many other languages. To C, a "character" is just an integer. It's a really small integer, but that's all it is. This means you can do math on them, and a lot of software does just that, for good or bad.

This last bit is your first glance at how C gives you direct access to the machine. We'll be exploring that more in later exercises.

As usual, here's what you should see for the output:

Again, go through this and try breaking the printf by passing in the wrong arguments. See what happens when you try to print out that nul_byte variable too with %s vs. %c. When you break it, run it under Valgrind to see what it says about your breaking attempts.

• Make the number you assign to universe_of_defects various sizes until you get a warning from the compiler.
• What do these really huge numbers actually print out?
• Change long to unsigned long and try to find the number that makes that one too big.
• Go search online to find out what unsigned does.
• Try to explain to yourself (before I do in the next exercise) why you can multiply a char and an int.

In the last exercise you did math, but with a '\0' (nul) character. This may be odd coming from other languages, since they try to treat "strings" and "byte arrays" as different beasts. C however treats strings as just arrays of bytes, and it's only the different printing functions that know there's a difference.

Before I can really explain the significance of this, I have to introduce a few more concepts: sizeof and arrays. Here's the code we'll be talking about:

In this code we create a few arrays with different data types in them. Because arrays of data are so central to how C works, there's a huge number of ways to create them. For now, just use the syntax type name[] = {initializer}; and we'll explore more. What this syntax means is, "I want an array of type that is initialized to {..}." When C sees this it does the following:

• Look at the type, in this first case it's int.
• Look at the [] and see that there's no length given.
• Look at the initializer, {10, 12, 13, 14, 20} and figure out that you want those 5 ints in your array.
• Create a piece of memory in the computer, that can hold 5 integers one after another.