stdio.h

Obviously we’ve been using the stdio.h header from the very start. We have already used the two most useful functions (for our purposes): printf() and scanf(). The other functions in this header revolve around access to files. The microcontrollers we’ll be working with in the coming chapters do sometimes have filesystems, but the types of programs we’ll be writing won’t need that particular feature. Still, if you do want to work with files on a desktop or high-powered microcontroller, this header is a good place to start!

stdlib.h

We have also seen a few functions from stdlib.h, namely malloc() and free(). But this header has a few more useful tricks worth mentioning.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  int total = 0;
  for (int i = 1; i < argc; i++) {
    total += atoi(argv[i]);
  }
  printf("The sum of these %d numbers is %d
", argc - 1, total);
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
  printf("RAND_MAX: %d
", RAND_MAX);
  unsigned int r1 = rand();
  printf("First random number: %d
", r1);
  srand(5);
  printf("Second random number: %d
", rand());
  srand(time(NULL));
  printf("Third random number: %d
", rand());
  unsigned int pin = rand() % 9000 + 1000;
  printf("Random four digit number: %d
", pin);
}

ch07$ gcc random.c
ch07$ ./a.out
RAND_MAX: 2147483647
First random number: 1804289383
Second random number: 590011675
Third random number: 1205842387
Random four digit number: 7783

ch07$ ./a.out
RAND_MAX: 2147483647
First random number: 1804289383
Second random number: 590011675
Third random number: 612877372
Random four digit number: 5454

#include <stdio.h>
#include <stdlib.h>

void confirm() {
  char answer;
  printf("Are you sure you want to exit? (y/n) ");
  scanf("%c", &answer);
  if (answer == 'y' || answer == 'Y') {
    printf("Bye

");
    exit(0);
    printf("This will never be printed.
");
  }
}

int main() {
  printf("In main... let's try exiting.
");
  confirm();
  printf("Glad you decided not to leave.
");
}

ch07$ gcc areyousure.c
ch07$ ./a.out
In main... let's try exiting.
Are you sure you want to exit? (y/n) y
Bye

ch07$ ./a.out
In main... let's try exiting.
Are you sure you want to exit? (y/n) n
Glad you decided not to leave.

string.h

Strings are so common and so useful that they even have their own header file. The string.h header can be added to any program where you need to compare or manipulate strings beyond simply storing and printing them. This header describes more functions than we have time to cover here, but there are some import utilities we want to highlight in Table 7-1.

We can demonstrate all of these functions in a simple program, ch07/fullname.c, by asking the user for their full name in pieces and (safely!) putting it together at the end. If we find we’re interacting with Dennis M. Ritchie, we’ll thank him for writing C.

#include <stdio.h>
#include <string.h>

int main() {
  char first[20];
  char middle[20];
  char last[20];
  char full[60];
  char spacer[2] = " ";

  printf("Please enter your first name: ");
  scanf("%s", first);
  printf("Please enter your middle name or initial: ");
  scanf("%s", middle);
  printf("Please enter your last name: ");
  scanf("%s", last);

  // First, assemble the full name
  strncpy(full, first, 20);
  strncat(full, spacer, 40);
  strncat(full, middle, 39);
  strncat(full, spacer, 20);
  strncat(full, last, 19);

  printf("Well hello, %s!
", full);

  int dennislen = 17;  // length of "Dennis M. Ritchie"
  if (strlen(full) == dennislen &&
      strncmp("Dennis M. Ritchie", full, dennislen) == 0)
  {
    printf("Thanks for writing C!
");
  }
}

And an example run:

ch07$ gcc fullname.c
ch07$ ./a.out
Please enter your first name: Alice
Please enter your middle name or initial: B.
Please enter your last name: Toklas
Well hello, Alice B. Toklas!

Give this program a try yourself. If you do enter Dennis’s name (including the period after his middle initial: “M.”), do you get the thank-you message as expected?

As another example, we can revisit the notion of default values and overwriting arrays from “Initializing strings”. You can delay the initialization of a character array until you know what the user has done. We can declare—but not initialize—a string, use it with scanf(), and then go back to the default if the user didn’t give us a good alternate value.

Let’s try this with a question about the background color of some future, amazing application. We might assume a dark theme with a black background. We can prompt the user for a different value, or have them simply hit the Return key without entering a value if they want to keep the default. Here’s ch07/background.c:

#include <stdio.h>
#include <string.h>

int main() {
  char background[20];                                     
  printf("Enter a background color or return for the default: ");
  scanf("%[^
]s", background);                            
  if (strlen(background) == 0) {                           
    strcpy(background, "black");
  }
  printf("The background color is now %s.
", background); 
}

Declare a string with enough capacity, but don’t set it to anything.

Get input from the user and store it in our array.

If the array is empty after prompting the user, store our default.

Show the final value, either from the user or from our default.

And here are some sample runs, including one where we keep the black background:

ch07$ gcc background.c
ch07$ ./a.out
Enter a background color or return for the default: blue
The background color is now blue.
ch07$ ./a.out
Enter a background color or return for the default: white
The background color is now white.
ch07$ ./a.out
Enter a background color or return for the default:
The background color is now black.

If you are inviting the user to supply a value, just remember to allocate sufficient room in your array to contain whatever response the user might give you. If you can’t trust your users, scanf() has another trick that you can deploy. Just like the format specifiers in printf(), you can add a width to any input field in scanf(). For our previous example, say, we could change to an explicit limit of 19 (saving room for that final '' character):

  scanf("%19[^
]s", background);

Easy peasy. It does look quite dense, but it’s a nice option for limited devices where you might not be able to allocate a lot of extra space in case of verbose users.

math.h

The math.h header declares several useful functions for performing a variety of arithmetic and trigonometric calculations. Table 7-2 includes several of the more popular functions. All of these functions return a double value.

For any situation where you want an int or long answer, you just have to cast. For example, we could write a simple program (ch07/rounding.c) to average several integers and then round them to the nearest int value like this:

#include <stdio.h>
#include <math.h>

int main() {
  int grades[6] = { 86, 97, 77, 76, 85, 90 };
  int total = 0;
  int average;

  for (int g = 0; g < 6; g++) {
    total += grades[g];
  }
  printf("Raw average: %0.2f
", total / 6.0);
  average = (int)floor(total / 6.0 + 0.5);
  printf("Rounded average: %d
", average);
}

Since we (may) need to help the compiler with this library, let’s take a look at the compile command:

gcc rounding.c -lm

Again, math.h declares functions in the C standard library, but those functions are not necessarily implemented in the same place as other functions. The binary containing most of the functions we’re discussing is libc (or glibc for GNU’s version). However, on many systems, the math functions live in a separate binary, libm, which requires that trailing -lm flag to make sure the compiler knows to link in the math library.

Your system may differ. There’s no harm in trying to compile without the -lm option to see if your system automatically includes libm (or has all of the functions already included in libc). If you try compiling without the flag and you don’t get any errors, you’re in good shape! If you do need the library flag, you’ll see something like this:

ch07$ gcc rounding.c
/usr/bin/ld: /tmp/ccP1MUC7.o: in function `main':
rounding.c:(.text+0xaf): undefined reference to `floor'
collect2: error: ld returned 1 exit status

Try it yourself (with or without the library flag as needed). You should get 85 as an answer. If rounding is something you do often, you can write your own function to simplify things and avoid littering your code with the slightly clunky business of adding the 0.5 value before calling floor() and casting the result.

time.h

This header gives you access to a number of utilities to help with determining and displaying time. It uses two types of storage for handling dates and times: a simple timestamp (with a type alias, time_t, representing the number of seconds since January 1, 1970, UTC) and a much more detailed structure, struct tm, with the following definition:

struct tm {
  int tm_sec;   // seconds (0 - 60; allow for leap second)
  int tm_min;   // minutes (0 - 59)
  int tm_hour;  // hours (0 - 23)
  int tm_mday;  // day of month (1 - 31)
  int tm_mon;   // month (0 - 11; WARNING! NOT 1 - 12)
  int tm_year;  // year (since 1900)
  int tm_wday;  // day of week (0 - 6)
  int tm_yday;  // day of year (0 - 365)
  int tm_isdst; // Daylight Saving Time flag
                // This flag can be in one of three states:
                // -1 == unavailable, 0 == standard time, 1 == DST.
}

I won’t be using this nifty structure with all the separated fields, but it can be useful if you are doing any work with dates and times, like you might find in a calendaring application. I will be using timestamps from, uh, time to time, as we’ve already seen in “rand() and srand()” for supplying a changing seed to the srand() function. Table 7-3 shows some functions that work with these simple values:

The definition of that last function, time(), might look a little weird. It both takes and returns a time_t pointer. You can call time() with either a NULL value or with a valid pointer to a variable of type time_t. If you use NULL, the current time is simply returned. If you supply a pointer, the current time is returned, but the variable pointed to is also updated with the current time. We only need the NULL option for our work with random numbers, but you’ll stumble on a few utility functions that use this pattern. It can be useful if you are working with heap memory.

ctype.h

Many situations where you process input from users require you to validate that the input conforms to some expected type or value. For example, a ZIP code should be five digits and a US state abbreviation should be two uppercase letters. The ctype.h header declares several handy functions for checking individual characters. It also has two helper functions that convert between upper- and lowercase. Table 7-4 highlights several of these functions.

Don’t forget your Boolean operators! You can easily expand these tests to ask questions like “is not whitespace” with the ! operator:

  if (!isspace(answer)) {
    // Not a blank character, so go ahead
    ...
  }

Filling In Strings

Let’s start our example by creating our account type including a string “name” field. The new struct is simple enough:

struct account {
  char name[50];
  double balance;
};

We can now use our string functions to load up name with actual content after our structure is created. We can also use malloc() to create that structure in a function and return the address of our account. Here’s the new function, with some of the safety checks omitted just for readability:

struct account *create(char *name, double initial) {
  struct account *acct = malloc(sizeof(struct account));
  strncpy(acct->name, name, 49);
  acct->balance = initial;
  return acct;
}

Notice I chose to use strncpy() here. The idea is that I cannot guarantee the incoming name parameter will fit. Since I wrote the entire program, of course, I certainly can guarantee that detail, but that’s not the point. I want to make sure if I ever allow user input, say, by prompting the user for details, my create() function has some safeguards in place.

Let’s go ahead and create a function to print our account details. Hopefully, this code looks familiar from our work in Chapter 6. We can also start our main() function to try out everything we’ve written so far:

void print(struct account *a) {
  printf("Account: %s
", a->name);
  printf("Balance: $%.2f
", a->balance);
}

int main() {
  struct account *checking;
  checking = create("Bank of Earth (checking)", 200.0);
  print(checking);
  free(checking);
}

Let’s compile and run ch07/account1.c. Here’s our output:

ch07$ gcc account1.c
ch07$ ./a.out
Account: Bank of Earth (checking)
Balance: $200.00

Hooray! So far, so good. Next up is figuring out an interest payment.

Finding Our Interest

Using the pow() function from the math.h library, we can calculate a monthly compounded interest in one expression. I know I was taught this formula in high school, but I still have to look it up online any time I actually need to use it. Then we’ll update main() to add a year’s worth of interest (at 5%) to our account and print out the details again. Here are the new parts from ch07/account2.c:

void add_interest(struct account *acct, double rate, int months) {
  // Put our current balance in a local var for easier use
  double principal = acct->balance;
  // Convert our annual rate to a monthly percentage value
  rate /= 1200;
  // Use the interest formula to calculate our new balance
  acct->balance = principal * pow(1 + rate, months);
}

int main() {
  struct account *checking;
  checking = create("Bank of Earth (checking)", 200.0);
  print(checking);

  add_interest(checking, 5.0, 12);
  print(checking);

  free(checking);
}

That’s looking pretty good! Let’s compile and run account2.c. If your system needs the -lm math library flag, be sure to add it when you compile:

ch07$ gcc account2.c -lm
ch07$ ./a.out
Account: Bank of Earth (checking)
Balance: $200.00
Account: Bank of Earth (checking)
Balance: $210.23

Everything worked! Although you are reading the final output from my code after I fixed the various little mistakes I made while writing it. I reversed the order of the source and destination strings in strncpy(), for example. It’s rare to get everything right the first time. The compiler will usually let you know what you got wrong. You just head back to your editor and fix it. Getting comfortable with mistakes—and with fixing them!—is one of the reasons I encourage you to type in some of these examples. Nothing like actually writing code to get better at writing code.