C Program Structure and Data Types

• Standard. C11 (ISO/IEC 9899:2011), hosted implementation (a normal operating system with the full standard library).
• Data model for examples. Unless a question states otherwise, examples assume LP64, the model of 64-bit Linux and macOS with gcc or clang: char 1 byte, short 2, int 4, long 8, long long 8, pointers 8, and two's complement integers. The other common model, ILP32 (32-bit systems), differs only in long and pointers being 4 bytes. Windows 64-bit uses LLP64 (long 4 bytes, pointers 8).
• GATE convention. When a question gives sizes ("assume int is 4 bytes"), use them; they override everything here.

• Signed Number Representation: two's complement, needed for integer ranges and overflow.
• Basic binary and hexadecimal: Number Systems.

Structure of a C program

#include <stdio.h>          /* preprocessor directive: textual inclusion */
#define N 3                 /* macro: replaced before compilation */

int square(int x);          /* declaration (prototype) */

int main(void) {            /* execution starts here */
    int total = 0;          /* definition with initialisation */
    for (int i = 1; i <= N; i++)
        total += square(i);
    printf("sum of squares = %d\n", total);
    return 0;               /* 0 means success to the host */
}

int square(int x) { return x * x; }   /* definition */

1. Preprocessing. Lines starting with # are handled first: #include pastes a header, #define sets up text replacement. See The C Preprocessor.
2. Compilation. Each translation unit becomes an object file. A function must be declared before it is called; the prototype int square(int x); lets main call square, which is defined later.
3. Linking. Object files and the library are joined; every function or object that is used must be defined exactly once in the whole program.
4. Execution starts at main. In a hosted implementation the two portable forms are int main(void) and int main(int argc, char *argv[]). Reaching the closing brace of main is equivalent to return 0; (C99 onward), but only for main.

Tokens: identifiers, keywords and constants

• Identifiers consist of letters, digits and underscores and must not start with a digit. They are case-sensitive: Count and count are different. Names beginning with an underscore followed by an uppercase letter or a second underscore are reserved for the implementation.
• Keywords are reserved words that cannot be identifiers. C11 has 44 of them, from auto and break to _Static_assert and _Thread_local. Note that main, printf and NULL are not keywords.
• Comments /* ... */ do not nest; // comments run to the end of the line (C99 onward). Comments are replaced by a single space before preprocessing directives are executed.

The basic types

• sizeof(char) == 1 by definition. A "byte" in C is CHAR_BIT bits, at least 8.
• $\text{range(signed char)} \subseteq \text{range(short)} \subseteq \text{range(int)} \subseteq \text{range(long)} \subseteq \text{range(long long)}$.
• Each signed type has an unsigned counterpart of the same size.
• Whether plain char is signed or unsigned is implementation-defined. On x86 gcc it is signed (range $-128$ to $127$); on ARM Linux it is unsigned. char, signed char and unsigned char are three distinct types.

Ranges from the bit width

Constants and their types

• Integer constants. Decimal 42, octal 052 (leading zero), hexadecimal 0x2A. All three are the value 42. 08 is a compile error, because 8 is not an octal digit. A decimal constant without suffix gets the first of int, long, long long that can hold it; octal and hexadecimal constants may also become unsigned types. Suffixes: U (unsigned), L (long), LL (long long), combinable as UL, ULL.
• Floating constants. 1.5, 2e-3, .5 have type double. Suffix f gives float, L gives long double. So sizeof 1.5 is 8 but sizeof 1.5f is 4.
• Character constants. 'A' has type int in C (not char, unlike C++), so sizeof('a') == sizeof(int), which is 4 under LP64. Its value is the character's code: 65 in ASCII. Escape sequences include '\n', '\t', '\0' (value 0), '\\', '\'', octal '\101' and hex '\x41' (both 65).
• String literals. "abc" is an array of 4 char (the 3 characters plus the terminating '\0'), so sizeof "abc" is 4. Modifying a string literal is undefined behaviour. See Strings.

Character arithmetic

Integer division and remainder

Unsigned wrap-around versus signed overflow

• Unsigned arithmetic is performed modulo $2^n$. unsigned int u = 0; u = u - 1; gives 4294967295 for a 32-bit unsigned int. This is well defined.
• Signed overflow (a result outside the type's range, such as INT_MAX + 1) is undefined behaviour. It is not "wrap to negative"; the compiler may assume it never happens. See Undefined, Unspecified and Implementation-Defined Behaviour.
• Integer-to-integer conversion. Conversion to an unsigned type reduces modulo one more than that type's maximum value; with an 8-bit unsigned char, 255 plus 1 stores 0. An unrepresentable integer converted to a signed integer type has an implementation-defined result or raises an implementation-defined signal. This is not the floating-to-integer rule: finite floating values truncate toward zero, and an unrepresentable integral part makes the conversion undefined. See Type Conversions.

Floating-point values

• float f = 0.1f; then f == 0.1 is false (0): f is converted to double for the comparison, but the float approximation of 0.1 differs from the double approximation. f == 0.1f is true.
• For inexact computations where approximate numerical agreement is intended, choose a suitable absolute/relative tolerance rather than blindly testing equality; exact equality is valid when the specification calls for it.
• Mixed expressions convert to the wider floating type: 5 / 2 * 2.0 is 2 * 2.0, which is 4.0, because 5 / 2 is integer division done first. 5 / 2.0 * 2 is 5.0.

sizeof

printf and scanf format specifiers

• Sizes are implementation-defined; only minimum ranges and ordering are guaranteed. Always state or read the data model.
• 'a' is an int in C. sizeof('a') is sizeof(int), not 1.
• A leading zero makes an integer constant octal; 08 and 09 do not compile.
• Integer division truncates toward zero; the remainder has the sign of the dividend.
• Unsigned arithmetic wraps modulo $2^n$; signed overflow is undefined behaviour.
• The signedness of plain char is implementation-defined.
• The operand of sizeof is not evaluated (except for variable length arrays).
• Floating constants are double unless suffixed with f.

• Output prediction. Most C questions ask for printed output. Track each variable's type first, then its value; type decides whether / truncates, whether a value wraps and how printf prints it.
• Stated sizes. If the question says int is 2 bytes, the range is $-32768$ to $32767$ (two's complement) and 32767 + 1 in int is overflow.
• Octal trap. int a = 012; is 10, not 12.
• Character trap. printf("%d", 'A') prints 65; printf("%c", 65) prints A.
• Floating comparison trap. float x = 0.1; if (x == 0.1) is false; with 0.5 or 0.25 (exactly representable) it is true.
• Division trap. 3/2*2 is 2, while 3*2/2 is 3.

• Operators, Precedence and Side Effects: dependent. How expressions on these types are evaluated.
• Type Conversions and Integer Arithmetic: dependent. Promotions and the usual arithmetic conversions.
• Pointers: dependent. Pointer types and sizes.
• The C Preprocessor: dependent. #include and #define.
• Signed Number Representation: related. Two's complement behind the ranges.