Creating and Manipulating Arrays

As I mentioned, we used an array back in Chapter 2 (in “Getting User Input”) to allow for some user input. Let’s revisit that code (ch04/hello2.c) and pay more attention to the array of characters:

#include <stdio.h>

int main() {
  char name[20];

  printf("Enter your name: ");
  scanf("%s", name);
  printf("Well hello, %s!
", name);
}

So what exactly does that char name[20] declaration do? It creates a variable named “name” with a base type of char, but it is an array, so you get space to store multiple chars. In this case, we asked for 20 bytes, as illustrated in Figure 4-1.

Figure 4-1. An empty array of type char called name

And what happens with this array variable when we run the program? When you type in a name and hit Return on your keyboard, the characters you typed get placed in the array. Since we used scanf() and its string (%s) format field, we will automatically get a trailing null character ('' or sometimes '00') that marks the end of the string. In memory, the name variable now looks like Figure 4-2.

Figure 4-2. A char array with a string

Now when we use the name variable again in the subsequent printf() call, we can echo back all of the letters that were stored and the null character tells printf() when to stop, even if the name doesn’t occupy the entire array. Conversely, printing a string that does not have the terminating character will cause printf() to keep going after the end of the array and likely cause a crash.

ch04$ ./a.out
Enter your name: @AdmiralGraceMurrayHopper
Well hello, @AdmiralGraceMurrayHopper!
*** stack smashing detected ***: terminated
Aborted (core dumped)

#include <stdio.h>

int main() {
  double ledger[100];
  printf("Size of a double: %li
", sizeof (double));
  printf("Size of ledger: %li
", sizeof ledger);
  printf("Calculated ledger capacity: %li
", sizeof ledger / (sizeof (double)));
}

ch04$ gcc capacity.c
ch04$ ./a.out
Size of a double: 8
Size of ledger: 800
Calculated ledger capacity: 100

int days_in_month[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
char vowels[6] = { 'a', 'e', 'i', 'o', 'u', 'y' };
float readings[7] = { 8.9, 8.6, 8.5, 8.7, 8.9, 8.8, 8.5 };

int days_in_month[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
char vowels[] = { 'a', 'e', 'i', 'o', 'u', 'y' };
float readings[] = { 8.9, 8.6, 8.5, 8.7, 8.9, 8.8, 8.5 };

// Special initialization of a char array with a string literal
char secret[] = "password1";

// The printf() format string is usually a string literal
printf("Hello, world!
");

// And we can print literals, too
printf("The value stored in %s is '%s'
", "secret", secret);

  printf("The second vowel is: %c
", vowels[1]);
  printf("July has %d days.
", days_in_month[6]);

The second vowel is: e
July has 31 days.

  int month = 7;
  printf("July (month %d) has %d days.", month, days_in_month[month - 1]);

if (year % 4 == 0) {
  // Forgive the naive leap year calculation :)
  days_in_month[1] = 29;
}

float readings[10];
// ... interesting stuff goes here to set up the sensor and read it
readings[7] = latest_reading;

for (int m = 0; m < 12; m++) {
  // remember the array starts at 0, but humans start at 1
  printf("Days in month %d is %d.
", m + 1, days_in_month[m]);
}

Days in month 1 is 31.
Days in month 2 is 28.
Days in month 3 is 31.
Days in month 4 is 30.
Days in month 5 is 31.
Days in month 6 is 30.
Days in month 7 is 31.
Days in month 8 is 31.
Days in month 9 is 30.
Days in month 10 is 31.
Days in month 11 is 30.
Days in month 12 is 31.

float readings[] = { 8.9, 8.6, 8.5, 8.7, 8.9, 8.8, 8.5 };

// Use our sizeof trick to get the number of elements
int count = sizeof readings / sizeof (float);
float total = 0.0;
float average;
for (int r = 0; r < count; r++) {
  total += readings[r];
}
average = total / count;
printf("The average reading is %0.2f
", average);

Review of Strings

I have noted that strings are really just arrays of type char with some extra features supported by the language itself, such as literals. But since strings represent the easiest way to communicate with users, I want to highlight more of what you can do with strings in C.

#include <stdio.h>

int main() {
  char phrase[] = "Hello, world!";
  int i = 0;
  // keep looping until the end of the string
  while (phrase[i] != '') {
    if (phrase[i] == ',') {
      printf("Found a comma at position %d.
", i);
      break;
    }
    // try the next character
    i++;
  }
  if (phrase[i] == '') {
    // Rats. Made it to the end of the string without a match.
    printf("No comma found in %s
", phrase);
  }
}

Multidimensional Arrays

It may not be obvious since strings are already an array, but you can store an array of strings in C. But because there is no “string type” that you can use when declaring such an array, how do you do it? Turns out C supports the idea of a multidimensional array so you can create an array of char[] just like other arrays:

char month_names[][];

Seems fair. But what is not obvious in that declaration is what the pair of square bracket pairs refer to. When declaring a two-dimensional array like this, the first square bracket pair can be thought of as the row index, and the second is the column. Another way to think about it is the first index tells you how many character arrays we’ll be storing and the second index tells you how long each of those arrays can be.

We know how many months there are and a little research tells us the longest name is September, with nine letters. Add on one more for our terminating null character, and we could precisely define our month_names array like this:

char month_names[12][11];

You could also initialize this two-dimensional array since we know the names of the months and don’t require user input:

char month_names[12][11] = {
  "January", "February", "March", "April", "May", "June", "July",
  "August", "September", "October", "November", "December"
};

But here I cheated a little with the initialization by using string literals, so the second dimension of the month_names array isn’t readily apparent. The first dimension is the months, and the second (hidden) dimension is the individual characters that make up the month names. If you are working with other data types that don’t have this string literal shortcut, you can use nested curly brace lists like this:

int multiplication[5][5] = {
  { 0, 0, 0,  0,  0 },
  { 0, 1, 2,  3,  4 },
  { 0, 2, 4,  6,  8 },
  { 0, 3, 6,  9, 12 },
  { 0, 4, 8, 12, 16 }
};

It might be tempting to assume the compiler can determine the size of the multi-dimensional structure, but sadly, you must supply the capacity for each dimension beyond the first. For our month names, for example, we could start off without the “12” for how many names, but not without the “11” indicating the maximum length of any individual name:

// This shortcut is ok
char month_names[][11] = { "January", "February" /* ... */ };

// This shortcut is NOT
char month_names[][] = { "January", "February" /* ... */ };

You’ll eventually internalize these rules, but the compiler (and many editors) will always be there to catch you if you make a small mistake.

Accessing Elements in Multidimensional Arrays

With our array of month names, it is straightforward getting access to any particular month. It looks just like accessing the element of any other one-dimensional array:

printf("The name of the first month is: %s
", month_names[0]);

// Output: The name of the first month is: January

But how would we access an element in the multiplication two-dimensional array? We use two indices:

printf("Looking up 3 x 4: %d
", multiplication[3][4]);

// Output: Looking up 3 x 4: 12

Notice that in this multiplication table, the potentially strange use of zero as the first index value turns out to be a useful element. Index “0” gives us a row—or column—of valid multiplication answers.

And with two indices, you’ll need two loops if you want to print out all of the data. We can take the work we did in “Nested Loops and Tables” and use it to access our stored values rather than generating the numbers directly. Here’s the printing snippet from ch04/print2d.c:

  for (int row = 0; row < 5; row++) {
    for (int col = 0; col < 5; col++) {
      printf("%3d", multiplication[row][col]);
    }
    printf("
");
  }

And here is our nicely formatted table:

ch04$ gcc print2d.c
ch04$ ./a.out
  0  0  0  0  0
  0  1  2  3  4
  0  2  4  6  8
  0  3  6  9 12
  0  4  8 12 16

We’ll see some other options in Chapter 6 for more tailored multidimensional storage. In the near term, just remember that you can create more dimensions with more pairs of square brackets. While you’ll likely use one-dimensional arrays most of the time, tables are common enough and spatial data often fits in three-dimensional “cubes.” Few programmers will ever need it, especially those of us concentrating on microcontrollers, but C does support higher orders of arrays.

Binary, Octal, Hexadecimal

Before we tackle the operators in C that access and manipulate bits, let’s review some notation for discussing binary values. If we have a single bit, a 0 or a 1 are sufficient and that’s easy enough. However, if we want to store a dozen bits inside one int variable, we need a way to describe the value of that int. Technically, the int will have a decimal (base 10) representation, but base 10 does not map cleanly to individual bits. For that, octal and hexadecimal notation is much clearer. (Binary, or base 2, notation would obviously be clearest, but large numbers get very long in binary. Octal and hexadecimal—often just “hex”—are a good compromise.)

When we talk about numbers, we often implicitly use base 10, thanks to the digits (ooh, get it?) on our hands. Computers don’t have hands (discounting robots, of course) and don’t count in base 10. They use binary. Two digits, 0 and 1, make up the entirety of their world. If you group three binary digits, you can represent the decimal numbers 0 through 7, which is eight total numbers, so this is base 8, or octal. Add a fourth bit and you can represent 0 through 15, which covers the individual “digits” in hexadecimal. Table 4-1 shows these first 16 values in all four bases.

You might notice that I always showed eight numbers for the binary column, three for octal, and two for hex. The byte (8 bits) is a very common unit to work with in C. Binary numbers often get shown in groups of four, with as many groups as required to cover the largest number being discussed. So for a full byte of 8 bits, which can store any value between 0 to 255, for example, you would see a binary value with two groupings of four digits. Similarly, octal values with three digits can display any byte’s value, and hexadecimal numbers need two digits. Note also that hexadecimal literals are not case sensitive. (Neither is the “x” in the hexadecimal prefix, but an uppercase “X” can be harder to distinguish.)

We’ll be using binary notation from time to time when working with microcontrollers in the latter half of this book, but you may have already run into hexadecimal numbers if you have written any styled text in HTML or CSS or similar markup languages. Colors in these documents are often represented with the hex values for a byte of red, a byte of green, a byte of blue, and occasionally a byte of alpha (transparency). So a full red that ignores the alpha channel would be FF0000. Now that you know two hex digits can represent one byte, it may be easier to read such color values.

To help you get accustomed to these different bases, try filling out the missing values in Table 4-2. (You can check your answers with the Table 4-4 table at the end of the chapter.) The numbers are not in any particular order, by the way. I want to keep you on your toes!

Modern browsers can convert bases for you right in the search bar, so you probably won’t need to memorize the full 256 values possible in a byte. But it will still be useful if you can estimate the size of a hex value or determine if an octal ASCII code is probably a letter or a number.

Octal and Hexadecimal Literals in C

The C language has special options for expressing numeric literals in octal and hex. Octal literals start with a simple 0 as a prefix, although you can have multiple zeroes if you are keeping all of your values the same width, like we did in our base tables. For hex values, you use the prefix 0x or 0X. You typically match the case of the ‘X’ character to the case of any of the A-F digits in your hex value, but this is just a convention.

Here’s a snippet showing how to use some of these prefixes:

int line_feed = 012;
int carriage_return = 015;
int red = 0xff;
int blue = 0x7f;

Some compilers support nonstandard prefixes or suffixes for representing binary literals, but as the “nonstandard” qualifier suggests, they are not part of the official C language.

Input and Output of Octal and Hex Values

The printf() function has built-in format specifiers to help you produce octal or hexadecimal output. Octal value can be printed with the %o specifier and hex can be shown with either %x or %X, depending on whether you want lower- or uppercase output. These specifiers can be used with variables or expressions of any of the integer types in any base, which makes printf() a pretty easy way to convert from decimal to octal or hex. We could easily produce a table similar to Table 4-1 (minus the binary column) using a loop and a single printf(). We can take advantage of the width and padding options of the format specifier to get our desired three octal digits and two hex digits. Take a look at ch04/dec_oct_hex.c:

#include <stdio.h>

int main() {
  printf(" Dec  Oct  Hex
");
  for (int i = 0; i < 16; i++) {
    printf(" %3d  %03o  0x%02X
", i, i, i);
  }
}

Notice that we just reuse the exact same variable for each of the three columns. Also notice that when printing the hexadecimal version, I manually added the “0x” prefix—it is not included in the %x or %X formats. Here are a few of the first and last lines:

ch04$ gcc dec_oct_hex.c
ch04$ ./a.out
 Dec  Oct  Hex
   0  000  0x00
   1  001  0x01
   2  002  0x02
   3  003  0x03
 ...
  13  015  0x0D
  14  016  0x0E
  15  017  0x0F

Neat. Just the output we wanted. On the input side using scanf(), the format specifiers work in an interesting way. They are all still used to get numeric input from the user. The different specifiers now perform base conversion on the number you enter. If you specify decimal input (%d), you cannot use hex values. Conversely, if you specify hex input (%x or %X) and only enter numbers (i.e., you don’t use any of the A-F digits), the number will still be converted from base 16.

We can illustrate this with a simple converter program, ch04/rosetta.c, that will translate different inputs to all three bases on output. We can set which type of input we expect in the program but use an if/else if/else block to make it easy to adjust. (Although recompiling will still be required.)

#include <stdio.h>

int main() {
  char base;
  int input;

  printf("Convert from? (d)ecimal, (o)ctal, he(x): ");
  scanf("%c", &base);

  if (base == 'o') {
    // Get octal input
    printf("Please enter a number in octal: ");
    scanf("%o", &input);
  } else if (base == 'x') {
    // Get hex input
    printf("Please enter a number in hexadecimal: ");
    scanf("%x", &input);
  } else {
    // assume decimal input
    printf("Please enter a number in decimal: ");
    scanf("%d", &input);
  }
  printf("Dec: %d,  Oct: %o,  Hex: %x
", input, input, input);
}

Here are a few example runs:

ch04$ gcc rosetta.c

ch04$ ./a.out
Convert from? (d)ecimal, (o)ctal, he(x): d
Please enter a number in decimal: 55
Dec: 55,  Oct: 67,  Hex: 37

ch04$ ./a.out
Convert from? (d)ecimal, (o)ctal, he(x): x
Please enter a number in hexadecimal: 37
Dec: 55,  Oct: 67,  Hex: 37

ch04$ ./a.out
Convert from? (d)ecimal, (o)ctal, he(x): d
Please enter a number in decimal: 0x37
Dec: 0,  Oct: 0,  Hex: 0

Interesting. The first two runs went according to plan. The third run didn’t create an error but didn’t really work, either. What happened here is a sort of “feature” of scanf(). It tried very hard to bring in a decimal number. It found the character 0 in our input, which is a valid decimal digit, so it started parsing that character. But it next encountered the x character which is not valid for a base 10 number. So that was the end of the parsing and our program converted the value 0 into each of the three bases.

Try running this program yourself and switch the mode a few times. Do you get the behavior you expect? Can you cause any errors?

Knowing what we do about the difference between %i and other numeric specifiers in scanf(), can you see how to make this program a little simpler? It should be possible to accept any of the three bases for input without the big if statement. I’ll leave this problem to you as an exercise, but you can see one possible solution in the rosetta2.c file in the code examples for this chapter.

Bitwise Operators

Starting out on limited hardware like C did means occasionally working with data at the bit level quite apart from printing or reading in binary data. C supports this work with bitwise operators. These operators allow you to tweak individual bits inside int variables (or char or long, of course). We’ll see some fun uses of these features with the Arduino microcontroller in Chapter 10.

Table 4-3 describes these operators and shows some examples that make use of the following two variables:

char a = 0xD; // 1101 in binary
char b = 0x7; // 0111 in binary

You can technically apply bitwise operators to any variable type to tweak particular bits. They are rarely used on floating point types, though. You usually pick an integral type that is big enough to hold however many individual bits you need. Because they are “editing” the bits of a given variable, you often see them used with compound assignment operators (op=). If you have five LEDs, for example, you could keep track of their on/off state with a single char type variable, as in this snippet:

char leds = 0;  // Start with everyone off, 0000 0000

leds |= 8;    // Turn on the 4th led from the right, 0000 1000
leds ^= 0x1f; // Toggle all lights, 0001 0111
leds &= 0x0f; // Turn off 5th led, leave others as is, 0000 0111

Five int or char values likely won’t make the difference in whether you can store or run a program on a microcontroller, even ones with only one or two kilobytes of memory, but those small storage needs do add up. If you’re tracking a panel of LEDs with hundreds or thousands of lights, it makes a difference how tightly you can store their state. One size rarely fits all, so remember your options and pick one that balances between ease of use and any resource constraints you have.