Data Types & I/O

Types of Data Types in C

C organizes data types into three broad categories. Understanding this classification helps you pick the right type for each problem and explains why some types are built-in while others you create yourself.

• Primary / Basic data types: int, char, float, double — the atomic types provided directly by the language
• Derived data types: built from basic types — array, pointer, function (covered in later tutorials)
• User-defined data types: created by the programmer — struct, union, enum, typedef

Type modifiers change the size or signedness of basic types:

• signed / unsigned — control whether negative values are allowed (unsigned int stores only ≥ 0)
• short / long / long long — change integer width (short int, long int, long long int)
• long (with double) — extended-precision floating point (long double)

Data Types Reference Table

Use this table as a quick reference when declaring variables or choosing format specifiers. Sizes and ranges are approximate and implementation-dependent — they are typical values on common desktop compilers (GCC/MSVC on 32/64-bit systems).

printf() — formatted output

printf() displays formatted text on the screen. It is declared in <stdio.h>. The general syntax is:

printf("format string", arg1, arg2, ...);

• Format string — text in double quotes with conversion specifiers like %d, %f
• Arguments — variables whose values replace the specifiers, in the same order
• Escape sequences: \n (newline), \t (tab), \\ (backslash)

Common examples:

printf("Hello, World!\n");                    /* no variables */
printf("Age = %d\n", age);                    /* integer */
printf("Price = %.2f\n", price);              /* float, 2 decimals */
printf("Grade = %c\n", grade);                /* character */
printf("%d + %d = %d\n", a, b, a + b);    /* mixed */

scanf() — formatted input

scanf() reads formatted input from the keyboard (standard input). It is also declared in <stdio.h>. The general syntax is:

scanf("format string", &variable1, &variable2, ...);

• Use the address-of operator & before variable names (except arrays/strings)
• Format specifiers must match the variable types — same rules as printf
• scanf skips leading whitespace before numeric and string input
• Reading stops at whitespace for %s; use fgets() for lines with spaces

Common examples:

scanf("%d", &n);                         /* read integer into n */
scanf("%f", &price);                   /* read float */
scanf("%c", &ch);                       /* read single character */
scanf("%d %d", &a, &b);                /* read two integers */
scanf("%lf", &value);                   /* read double */

Format specifiers — quick cheat sheet

The format specifier in the format string tells printf and scanf how to interpret each value. Mismatching type and specifier is a top beginner mistake.

• %d — signed decimal integer (int)
• %u — unsigned decimal integer (unsigned int)
• %hd / %ld / %lld — short / long / long long integers
• %f — floating-point (float / double in printf)
• %lf — double in scanf
• %Lf — long double (capital L)
• %c — single character
• %s — string (char array)
• %.nf — float with n decimal places (e.g. %.2f)

Signed vs unsigned integers

By default, int, char, and short are signed — they can store negative values using two's complement representation. Adding unsigned removes the sign bit, doubling the positive range but forbidding negative values.

• signed int x = -10; — valid, stores −10
• unsigned int y = 10; — valid, stores 10
• unsigned int z = -1; — compiles but wraps to a large positive value
• Use %d for signed, %u for unsigned in printf
• Mixing signed and unsigned in comparisons can produce surprising results

The sizeof operator

sizeof is a compile-time operator that returns the size of a type or variable in bytes. It is essential for portable code because type sizes are not fixed by the C standard.

printf("sizeof(char)   = %zu bytes\n", sizeof(char));
printf("sizeof(int)    = %zu bytes\n", sizeof(int));
printf("sizeof(float)  = %zu bytes\n", sizeof(float));
printf("sizeof(double) = %zu bytes\n", sizeof(double));

• Returns type size_t — print with %zu
• Can be used as sizeof(int) or sizeof variable
• Does not evaluate its operand at runtime (except for variable-length arrays)

Why float vs double?

Both store floating-point numbers, but they differ in precision and memory:

• float — 4 bytes, ~6–7 significant digits; suffix f on literals: 3.14f
• double — 8 bytes, ~15 significant digits; default for floating literals: 3.14 is double
• long double — extended precision, size varies (8–16 bytes)
• Use float when memory is tight; use double for scientific/financial accuracy
• In printf, %f works for both float and double; use %lf in scanf for double

Format specifier precision — %.2f and more

You can control width and decimal places by inserting numbers between % and the letter:

• %.2f — print float with exactly 2 digits after the decimal (rounded)
• %10d — print integer in a field of width 10 (right-aligned)
• %-10d — left-aligned in width 10
• %05d — pad with zeros: 00042
• %.4f — four decimal places for higher precision output

float pi = 3.14159265f;
printf("Default: %f\n", pi);       /* 3.141593 */
printf("Two dec: %.2f\n", pi);     /* 3.14 */
printf("Four dec: %.4f\n", pi);    /* 3.1416 */

scanf pitfalls — & required, buffer leftovers

Two classic scanf problems cause more debugging hours than almost anything else in beginner C:

1. Forgetting the address-of operator (&):

int n;
scanf("%d", n);    /* WRONG — undefined behavior */
scanf("%d", &n);   /* CORRECT */

2. Leftover newline after numeric input:

int num;
char ch;
scanf("%d", &num);        /* user types 10 and Enter */
scanf("%c", &ch);         /* reads leftover '\n', not your char! */
scanf(" %c", &ch);       /* space skips whitespace — FIX */

Type conversion and truncation

C performs implicit conversions when assigning between types. Converting from a larger range to a smaller type truncates — excess bits are lost:

• int x = 3.9; → x becomes 3 (fraction discarded)
• char c = 300; → c keeps only lower 8 bits (value depends on char signedness)
• float f = 5; → f becomes 5.0 (int promoted to float)
• Explicit cast: (float)a / b forces floating-point division
• Always check whether the target type can hold the value before assigning