Predecessor - scanf()

Some educational materials still reference scanf(), but in current Visual Studio versions, this function has been deprecated and replaced with scanf_s().

Why scanf_s() is Preferred

The scanf_s() function represents Microsoft's secure version of the standard input function, introduced starting from VC++ 2005. When invoking this function, you must specify a numeric value indicating the maximum number of characters to read. Many functions appended with "_s" suffix exist to enhance security compared to their original counterparts by accepting size parameters related to buffer dimensions. This prevents access to non-existent elements and protects against exploitation of vulnerabilities present in the original unsafe implementations. Essentially, scanf_s provides enhanced safety over scanf, though it requires additional parameters specifying variable lengths (in bytes). For instance: char buffer[20]; should be written as scanf_s("%s", buffer, 20); where the parameter 20 improves accuracy and prevents buffer overflow.

Critical Considerations

Consider the following problematic code:

#include <cstdio>

double x, y, z;
scanf_s("%f%f%f", &x, &y, &z);
printf("%f %f %f\n", x, y, z);

Output result:

512181.000000 17989019.000000 86000000.000000

The output displays three random numbers instead of expected values. What causes this?

When scanf_s reads with %f format specifier, the system reads data using 4-byte length allocation, intended for float storage locations. Since double variables occupy 8 bytes (twice the size), they cannot proeprly accommodate the 4-byte float data. Unlike the relationship between int and long types where simple byte extension occurs, float and double utilize distinct data formatting structures. When data is read in float format but stored in double space, then processed as double throughout subsequent operations, the sign bit, exponent, and mantissa become misaligned. This alignment issue corrupts the data representation.

The correct implementation should be:

#include <cstdio>

double x, y, z;
scanf_s("%lf%lf%lf", &x, &y, &z);
printf("%.2f %.2f %.2f\n", x, y, z);

Key Guidelines

(1) printf Format Specifiers

The %f specifier in printf handles both float and double types. Due to "default argument promotion" rules applicable in variadic paramter lists like printf, float values get promoted to double automatically. Therefore, printf processes only double-precision numbers regardless of input type.

(2) scanf Type Matching

For scanf operations, strict type matching is essential: use %f for float types and %lf for double types. Unlike printf, scanf works with pointers with out automatic type promotion. Storing float data in double locations or vice versa through pointer operations creates significant differences in memory layout and data interpretation.

(3) Portability Considerations

While %lf isn't officially defined in printf specifications, many systems accept it. For maximum portability, consistently use %f with printf. To control decimal precision, utilize format specifiers like:

printf("%.8f", value);

This ensures 8 decimal places display correctly across different platforms.