22 Output

22.1 printf — output with a format

The name printf is short for print formatted — “print it as the format says.” The first material is the format string, and the remaining materials are the values to be fitted into the format’s blanks:

printf(format string, value1, value2, ...)

The format string is a frame. Ordinary characters flow straight out, and only the places beginning with % — a conversion specification — are treated as blanks, into which the following value is fitted, turned into characters. This book’s minimal set is three:

• %d — turns an integer value into decimal characters and fits it in (decimal).
• %s — fits a string in as it is (string).
• %% — not a blank; used when you want to print the percent character itself.

Here is the demonstration. Two values go into two blanks in order:

#include <stdio.h>

int main(void)
{
    printf("The answer to %s is %d.\n", "life, the universe and everything", 6 * 7);
    return 0;
}

The answer to life, the universe and everything is 42.

A string literal went into the %s slot and the value of the expression 6 * 7 into the %d slot, completing the sentence. The format is the frame, the materials go in order — that is the whole of reading printf. (Conversion specifications have many side branches such as field widths, but they are introduced one at a time as needed; the full list is reference material in the appendix.)

22.2 Kinds of blank — a slot per kind of value

%d and %s carry you a fair way, but each kind of value has its own blank. Learn the common ones first.

/* The common conversion specifications, and lining things up with width and
   precision. Part IV has not met variables yet, so every argument here is a
   constant or an expression. */
#include <stdio.h>

int main(void)
{
    puts("[a different blank for each kind of value]");
    printf("  integer   %%d  -> %d\n", 42);
    printf("  real      %%f  -> %f\n", 3.14);
    printf("  character %%c  -> %c\n", 'A');
    printf("  string    %%s  -> %s\n", "hello");
    printf("  hex       %%x  -> %x\n", 255);
    printf("  percent   %%%%  -> %%\n");

    puts("\n[width — reserve the columns and things line up]");
    printf("  |%d|%d|\n", 7, 1234);
    printf("  |%6d|%6d|   <- six columns, right aligned\n", 7, 1234);
    printf("  |%-6d|%-6d|   <- a minus means left aligned\n", 7, 1234);
    printf("  |%06d|          <- a 0 fills the blanks with zeros\n", 42);

    puts("\n[precision — how many places after the point]");
    printf("  %%f    -> %f      <- six places by default\n", 2.0 / 3.0);
    printf("  %%.2f  -> %.2f          <- rounded to two\n", 2.0 / 3.0);
    printf("  %%8.2f -> |%8.2f|      <- width and precision together\n", 2.0 / 3.0);
    printf("  %%.3s  -> %.3s        <- on a string: 'how many characters'\n", "abcdef");

    puts("\n[making a table]");
    printf("  %-8s %6s\n", "item", "count");
    printf("  %-8s %6d\n", "apple", 3);
    printf("  %-8s %6d\n", "banana", 12);
    printf("  %-8s %6.1f\n", "weight", 4.25);

    puts("\n[but width counts BYTES — Hangul does not line up]");
    printf("  %-8s %6d\n", "사과", 3);
    printf("  %-8s %6d\n", "바나나", 12);
    puts("  one Hangul syllable is 3 bytes in UTF-8, so eight columns");
    puts("  are not eight characters.");

    puts("\n[the other windows for output]");
    puts("  puts prints one string and the newline for you");
    putchar(' '); putchar(' '); putchar('p'); putchar('c'); putchar('\n');
    fprintf(stdout, "  fprintf(stdout, ...) is the same as printf\n");
    fprintf(stderr, "  fprintf(stderr, ...) goes out on the error band\n");
    return 0;
}

  fprintf(stderr, ...) goes out on the error band
[a different blank for each kind of value]
  integer   %d  -> 42
  real      %f  -> 3.140000
  character %c  -> A
  string    %s  -> hello
  hex       %x  -> ff
  percent   %%  -> %

[width — reserve the columns and things line up]
  |7|1234|
  |     7|  1234|   <- six columns, right aligned
  |7     |1234  |   <- a minus means left aligned
  |000042|          <- a 0 fills the blanks with zeros

[precision — how many places after the point]
  %f    -> 0.666667      <- six places by default
  %.2f  -> 0.67          <- rounded to two
  %8.2f -> |    0.67|      <- width and precision together
  %.3s  -> abc        <- on a string: 'how many characters'

[making a table]
  item      count
  apple         3
  banana       12
  weight      4.2

[but width counts BYTES — Hangul does not line up]
  사과        3
  바나나     12
  one Hangul syllable is 3 bytes in UTF-8, so eight columns
  are not eight characters.

[the other windows for output]
  puts prints one string and the newline for you
  pc
  fprintf(stdout, ...) is the same as printf

Integer, real, character, string — chapter 20 taught four ways of writing a constant, and here is one blank for each of the four. The remaining conversions (unsigned integers, pointers, sizes) arrive with the types that need them, and the full list is in appendix B.

22.3 Lining things up — width and precision

A blank can also say how wide and how precise. It pays off immediately when making a table.

Remember the reading order and it never confuses: after % come alignment (-, 0) → width → dot and precision → the conversion letter.

22.4 Output has more than one window

Besides printf there are three more, each for a different place.

The last matters. A program has two bands going out (chapter 10) — standard output (stdout), where results flow, and standard error (stderr), where error messages flow.

printf("result: %d\n", 42);                   /* standard output */
fprintf(stderr, "cannot open the file\n");    /* standard error */

They are separated because of redirection (chapter 10). Send the results to a file and the error messages must still reach the screen; pipe the results to the next program and error messages must not be mixed in. “Results to standard output, words for a human to standard error” is the discipline of a program that behaves like a tool (the same grain as chapter 53′s exit status).

22.5 Matching — the contract between format and materials

A format string is a contract. The number and kinds of blanks promise the number and kinds of materials that must follow. Write two %d and two integer values must follow; a %s slot must receive a string.

Break the promise — put a string in a %d slot, or supply too few materials — and it is outside the contract: undefined behaviour (the concept met in chapter 7 appears in a function’s manual too). Fortunately modern compilers catch most of these mismatches through the warnings switched on in chapter 17 (-Wall) — printf’s format checking is among the oldest and most dependable of the warning features.

22.6 Closing Part IV — rereading hello world

Time to keep the promise. Here are chapter 15′s six lines again.

#include <stdio.h>

int main(void)
{
    printf("Hello, world!\n");
    return 0;
}

Reading it: #include is a preprocessing directive pasting in the roster of the stdio toolbox (chapters 16 and 19), main’s block binds a list of statements (chapter 19), the expression statement of the printf call lets text flow onto standard output with a string literal as material (chapters 20, 21 and 22), and \n breaks the line (chapter 10). What was an incantation on first meeting has become almost entirely known sentences.

Exactly two lines remain on credit — the int and (void) of int main(void), and return 0. Both are unravelled only once you know the world of declarations, that is, how to make names and types yourself, and that is the next part. At the end of it the debt is settled in full — and then, at last, we get to take input too.