Formatted Console I/O with printf and scanf

A Deeper Look at printf: Formatted Output

You've already used printf to display simple text and the results of the sizeof operator. Now, let's explore its full power. The 'f' in printf stands for 'formatted', meaning you can control how your data is displayed.

This is done using format specifiers inside the string argument. A format specifier is a placeholder that begins with % and tells printf to expect an additional argument and how to format it.

Common format specifiers include:

• %d or %i: For signed integers (int).
• %f: For floating-point numbers (float, double).
• %c: For a single character (char).
• %s: For a string (which in C is an array of characters).
• %%: To print a literal % character.

You can also use escape sequences to print special characters that are not visible, like \n for a newline and \t for a tab.

Controlling Width and Precision

One of the most powerful features of printf is its ability to control the alignment and precision of the output. This is particularly useful for creating tidy, table-like displays, which might feel familiar given your background in data analysis.

• Width: You can specify a minimum width for your output. For example, %10d will print an integer in a field that is at least 10 characters wide. By default, it's right-aligned. You can left-align it by adding a minus sign: %-10d.
• Precision: For floating-point numbers, you can control the number of digits after the decimal point. For example, %.2f will print a float or double with exactly two decimal places.

You can combine these: %10.2f will print a floating-point number in a 10-character wide field with 2 decimal places.

For quick reference, here are some useful resources that summarize format specifiers, escape sequences, and width/precision options.

Reading User Input with scanf

Now for the other side of I/O: getting input from the user. The scanf function is the counterpart to printf. It reads data from the console, interprets it according to a format string, and stores the values into variables.

The syntax looks similar to printf, but with one crucial difference: you must pass the memory address of the variables you want to fill. You do this using the address-of operator, &.

int age;
printf("Enter your age: ");
scanf("%d", &age); // Note the &age, not just age

This is a fundamental concept in C that touches on pointers (which we'll cover in the next module). For now, think of it this way:

• printf only needs a copy of the value to display it.
• scanf needs to know where the variable lives in memory so it can go to that location and place the new value there. The & operator provides that address.

Common scanf Hazards and How to Avoid Them

Unlike its counterparts in languages like Python or Java, scanf can be tricky and is a common source of bugs for beginners. Understanding its behavior and pitfalls is key to writing robust code.

Hazard 1: The Leftover Newline

When you use scanf("%d", &num) and the user types 42 followed by Enter, scanf reads the 4 and 2, converts them to an integer, and stops. The newline character (\n) from the Enter key is left sitting in the input buffer. If your next I/O call expects to read a character or a line of text, it might read this leftover newline immediately, causing your program to skip ahead unexpectedly.

The Fix: A common trick is to put a space before the %c specifier in the next scanf call (e.g., scanf(" %c", &my_char);). The leading space tells scanf to skip any and all whitespace characters (including newlines) before it reads the actual character.

Hazard 2: Buffer Overflow with %s

When you use scanf("%s", name), it reads characters into the name array until it encounters whitespace. It does not check if there's enough space in the array. If the user types a word that is longer than your array can hold, scanf will happily write past the end of the array, corrupting other parts of your program's memory. This is a classic security vulnerability called a buffer overflow.

The Fix: Always specify a width limit that is one less than your array size to leave room for the null terminator. For example, if you have char name[20];, use scanf("%19s", name);.

Hazard 3: Ignoring the Return Value

scanf returns the number of items it successfully read and assigned. If you expect two inputs (scanf("%d %f", ...)), the return value should be 2. If the user enters invalid data (e.g., "hello" for an integer), the conversion will fail, and the return value will be less than expected. If you don't check this, your program will continue executing with uninitialized or stale data in your variables.

The Fix: Always check the return value of scanf to confirm that the input was valid.

int items_read = scanf("%d", &age);
if (items_read != 1) {
    // Handle the error, e.g., print a message and exit
    printf("Invalid input. Please enter a number.\n");
    return 1; // Exit with an error code
}

Practical Exercise

Let's combine everything you've learned.

1. Create a new C file named user_info.c.
2. Write a program that asks the user for the following information:
   • Their first name (as a single word).
   • Their age.
   • Their favorite single character.
   • Their GPA (as a floating-point number).
3. Use printf to create clear prompts for the user.
4. Use scanf to read their inputs. Remember to:
   • Use the correct format specifiers (%s, %d, %c, %f or %lf). Notice the space before %c!
   • Use the & operator correctly for the variables.
   • Add a width limit to your %s to prevent buffer overflows (e.g., if you have char name[50], use "%49s").
5. After reading all the inputs, print a formatted summary message. For example:
   --- User Profile ---
Name: John
Age: 25
Favorite Initial: J
GPA: 3.80

Compile and run your program. Try giving it both valid and invalid input (e.g., text for age) to see how it behaves. Try removing the space before %c to see the "leftover newline" problem in action.

Conclusion

In this lesson, we took a comprehensive look at formatted console I/O in C. These functions are simple on the surface but have important nuances related to C's low-level memory model.

Key Takeaways:

• printf uses format specifiers (%d, %f, etc.) and escape sequences (\n, \t) to produce formatted output. You can control width and precision for clean, aligned text.
• scanf reads formatted input and requires the address-of operator (&) to know where in memory to store the data.
• scanf is powerful but requires careful handling. Always consider potential buffer overflows (with %s), the leftover newline problem (especially before %c), and the importance of checking its return value to validate input.

In our next lesson, we will officially introduce arrays. You'll learn how to declare and manipulate fixed-size lists of data. This will pave the way for a deeper understanding of strings in C, which are simply arrays of characters, and give more context to the scanf buffer overflow issue we discussed today.