C Programming Basics: Data Types, Operators, printf/scanf and Output Questions · সি প্রোগ্রামিংয়ের মৌলিক বিষয়: ডেটা টাইপ, অপারেটর, printf/scanf ও আউটপুট প্রশ্ন

1. The building blocks: tokens, keywords and identifiers

Where C comes from. Dennis Ritchie developed C at Bell Labs in 1972, from the earlier language B. It is often called a middle-level language: it has high-level structures but can also work close to the hardware (pointers, bit operations). The smallest complete program:

#include <stdio.h>   /* header file: declares printf */
int main(void) {     /* execution always starts in main */
    printf("Hello\n"); // a one-line comment (C99 and later)
    return 0;
}

Before it runs, a program passes through four stages: the preprocessor handles lines starting with # (#include, #define), the compiler turns C into assembly, the assembler makes an object file (.o or .obj), and the linker joins it with library code into an executable (.exe on Windows). Comments (/* … */, or // to the end of the line) are removed and never reach the compiled program.

The compiler first breaks a C program into tokens, the smallest units that mean something. There are six kinds:

Token kind	Examples
Keywords	int, float, if, for, return, static
Identifiers (names you choose)	total, main, _count, var_9
Constants (literals)	42, 3.14, 'A', 0x1A
String literals	"Hello"
Operators	+, =, ==, &&, ++, &
Punctuators (special symbols)	;, ,, (, ), {, }, [, ]

Keywords are reserved words that cannot be used as names. C89/C90 has 32 keywords (auto, break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, int, long, register, return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while). C99 added 5 (37 in all) and C11 added 7 more (44). Exams that say "C has 32 keywords" mean C89. Java has 50 keywords (including the unused goto and const), and Python 3 has 35 (True, False and None among them). sizeof is a keyword and an operator in C, but Java has no sizeof; in Java, objects are created with the new operator.

Identifier rules (C and C++; Java differs only where noted):

• Use only letters, digits and the underscore _ (Java also allows $).
• The first character must be a letter or an underscore, never a digit.
• No spaces or other symbols (#, -, @), and not a keyword.
• Names are case-sensitive: Total, total and TOTAL are three different names.

Name	Valid?	Why
var_9	Yes	Letters, digit and underscore
_	Yes in C/C++	A single underscore is a legal C name (in Java it is a keyword from Java 9)
9_var	No	Starts with a digit
No#of-students	No	# and - are not allowed
float	No	Keyword
star	Yes	Not a keyword (only struct, static etc. are)

Worked example 1: count the tokens. How many tokens are in printf("i = %d, &i = %x", i, &i);?

1. printf (identifier) → 1
2. ( → 2
3. "i = %d, &i = %x": a whole string literal is one token, whatever is inside it → 3
4. , i , → 4, 5, 6
5. & i → 7, 8
6. ) ; → 9, 10

Answer: 10 tokens. Spaces are not tokens, and nothing inside quotes is counted separately.

2. Data types and their sizes

A data type fixes how many bytes a variable uses, how its bits are read and which operations are allowed. C's types fall into four groups:

Classifications differ: many textbooks put void among the primary types (the usual keyed answer to "void is which type?"), and the C standard itself counts arrays, structures, unions, functions and pointers as derived types.

The C standard fixes only minimum ranges; sizeof(char) is always 1, and the rest depends on the compiler and machine:

Type	Standard minimum	Typical 32-bit (x86)	64-bit Windows	Typical 64-bit Linux	printf specifier
char	8 bits	1 byte	1 byte	1 byte	%c
short	16 bits	2	2	2	%hd
int	16 bits	4	4	4	%d or %i
long	32 bits	4	4	8	%ld
long long (C99)	64 bits	8	8	8	%lld
float	about 6 digits	4	4	4	%f
double	about 10 digits (15 in practice)	8	8	8	%f (printf), %lf (scanf)
long double	at least double	12 (gcc)	8 (MSVC), 16 (MinGW-w64)	16	%Lf
any pointer	–	4	8	8	%p

64-bit Windows keeps long at 4 bytes (the LLP64 model); 64-bit Linux makes it 8 (LP64).

So printf("%zu", sizeof(int)); prints 4 on today's compilers (exam papers often write %d, which works on most 32-bit systems but strictly needs %zu or a cast to int). Old 16-bit compilers such as Turbo C used a 2-byte int, which is why some older keys say 2; when the question gives no system, answer 4.

Ranges follow from the number of bits n: an unsigned type holds 0 to 2ⁿ − 1, and a signed type (two's complement) holds −2ⁿ⁻¹ to 2ⁿ⁻¹ − 1.

Bits	Signed range	Unsigned range
8 (char)	−128 to 127	0 to 255
16 (short)	−32,768 to 32,767	0 to 65,535
32 (int)	−2,147,483,648 to 2,147,483,647	0 to 4,294,967,295

Java fixes every size on every machine: byte 1 byte, short 2, int 4, long 8, float 4, double 8 and char 2 (a UTF-16 code unit); the size of boolean is not specified. Python has no fixed-size integers: an int grows as needed (2**100 prints 1267650600228229401496703205376), and a Python float is a C double.

3. Variables, constants and literals

A variable is a named memory location. int age; declares it, int age = 30; declares and initializes it, and age = 31; assigns a new value.

• A local variable (inside a function) that is not initialized holds an indeterminate ("garbage") value in C. Global and static variables start at 0.
• In Java, a local variable must be assigned before use, or the program does not compile; fields of an object get default values (0, false, null). So Test t; System.out.println(t.i); is a compile error ("variable t might not have been initialized"), while Test t = new Test(); prints 0 for an int field.

Point	Local variable	Global variable
Declared	Inside a function or block	Outside all functions
Visible	Only in that function or block	In every function after its declaration
Lifetime	While the function runs	The whole program run
Default value	Garbage (indeterminate)	0

Constants are values that cannot change:

• const int MAX = 100;: a typed, read-only variable.
• #define PI 3.14159: a preprocessor macro, replaced as text before compiling (no type, no =, no semicolon).
• enum color { RED, GREEN, BLUE }; gives named integer constants 0, 1, 2.
• Java uses final (final int MAX = 100;); Python has no true constants, only the naming custom MAX = 100.

Literals and their types:

Literal	Meaning	Type
26	Decimal	int
032	Octal (leading 0) = 26	int
0x1A	Hexadecimal = 26	int
26L, 26U	Long, unsigned	long, unsigned int
1.414	Floating constant	double (not float!)
1.414f or 1.414F	Floating constant	float
'A'	Character constant = 65	int in C (char in C++)
"A"	String: 'A' plus '\0'	array of 2 char

Because a character is stored as its code, 'A' is 65, 'a' is 97 ('a' - 'A' = 32) and '0' is 48. In C, sizeof('A') is sizeof(int) (4), but in C++ it is 1. Escape sequences: \n new line, \t tab, \0 null character (ends every string), \\ backslash, \' and \" quotes.

4. Operators, precedence and associativity

Group	Operators
Arithmetic	+ - * / %
Relational	< <= > >= == != (result 1 or 0 in C)
Logical	&& || ! (short-circuit)
Bitwise	& | ^ ~ << >>
Assignment	= += -= *= /= %= and so on
Increment / decrement	++ --
Conditional	?:
Special	sizeof, , (comma), & (address of), * (indirection), . and -> (member access)

Precedence says which operator binds first; associativity settles ties between operators of the same level:

Level (high → low)	Operators	Associativity
1	() [] -> . postfix ++ --	Left to right
2	prefix ++ --, unary + -, ! ~, * (indirection), & (address), sizeof, casts	Right to left
3	* / %	Left to right
4	+ -	Left to right
5	<< >>	Left to right
6	< <= > >=	Left to right
7	== !=	Left to right
8 – 10	&, then ^, then |	Left to right
11 – 12	&&, then ||	Left to right
13	?:	Right to left
14	= += -= …	Right to left
15	,	Left to right

The rules exams test most:

• *, / and % share one level, above + and -. So 2 + 3 * 4 - 10 / 2 % 3 = 2 + 12 − (5 % 3) = 2 + 12 − 2 = 12, and 7 / 2 * 2 = 3 × 2 = 6 (left to right).
• Integer division truncates toward zero (fixed by C99; C89 left negatives to the compiler): 7 / 2 = 3, -7 / 2 = −3. The remainder takes the sign of the dividend: -7 % 2 = −1, 7 % -2 = 1, and 5 % 1 = 0. In C, % works only on integers (use fmod for floating values). Java behaves like C here. Python's // floors instead: -7 // 2 is −4 and -7 % 2 is 1.
• Assignment is right to left: d = c = 5 sets c, then d, to 5.
• The comma operator evaluates its operands left to right and gives the value of the right one: int a = (1, 2, 3); sets a to 3. (Without the parentheses the commas would separate declarations instead.)
• A relational operator gives 1 (true) or 0 (false) in C. So with x = 20, y = 10, z = 5, x > y > z is (20 > 10) > 5 = 1 > 5 = 0. (Python chains comparisons, so 20 > 10 > 5 is True there.)
• && and || short-circuit: with x = 0 and y = 0, after if (x++ && y++) x is 1 but y is still 0, because x++ gave 0 (false) and y++ never ran.
• Bitwise with 11 (1011) and 3 (0011): 11 | 3 = 11, 11 & 3 = 3, 11 ^ 3 = 8, ~11 = −12, 11 << 2 = 44, 11 >> 1 = 5. Use | to set a bit and & (with an inverted mask) to reset it. For a non-negative x, x & 7 equals x % 8.
• XOR swap without a third variable: a ^= b; b ^= a; a ^= b; turns a = 10, b = 20 into 20 10.
• In Java, char values add as numbers: System.out.print('D' + 'E' + 'F'); prints 207 (68 + 69 + 70). But once a String appears, + joins text: 2 + 3 + "x" + 2 + 3 is 5x23.

A neighbouring C++ fact often asked here: the operators ::, ., .*, ?: and sizeof cannot be overloaded; ++, <<, () and ~ can. Java has no user-defined operator overloading.

5. Type conversion

Implicit conversion happens automatically. Small integer types (char, short) are first promoted to int; then, when two operands differ, the "lower" one is converted to the "higher" one:

Explicit conversion (a cast) is written (type) value. Converting a floating value to an integer truncates toward zero: (int)3.99 is 3 and (int)-3.99 is −3 (it never rounds).

Worked example 2: mixed types.

float p = 10.5;
int a = 5 * p + 5.0;
printf("%d\n", a);

1. 5 * p: the int 5 becomes float, giving 52.5.
2. 52.5 + 5.0: 5.0 is a double, so the sum is the double 57.5.
3. Storing 57.5 in an int drops the fraction.

Output: 57.

More conversions that cost marks:

• With int a = 7, b = 2;: a / b = 3, (double)a / b = 3.5, but (double)(a / b) = 3.0, because the division already happened in integers.
• Signed meets unsigned: -1 < 1u is 0 (false). The −1 is converted to unsigned int, where it becomes 4,294,967,295.
• Overflow: unsigned arithmetic wraps around: storing 255 + 1 back in an unsigned char (uc++ or uc = uc + 1) gives 0, although the expression uc + 1 itself is the int 256, because uc is promoted to int first. Overflow of a signed integer (INT_MAX + 1) is undefined behaviour in C. Storing an out-of-range value in a signed type is implementation-defined (gcc turns char c = 127; c++; into −128).
• Java widens automatically but needs a cast to narrow: int x = 3.5; does not compile. Java defines overflow: byte b = 127; b++; gives −128 and Integer.MAX_VALUE + 1 gives −2147483648.
• Python: int(3.99) is 3, int(-3.99) is −3, 7 / 2 is always 3.5 (true division) and round(2.5) is 2 (ties round to even).

6. Input and output: printf and scanf

Specifier	Used for
%d, %i	int (signed decimal)
%u	unsigned int
%ld, %lld, %hd	long, long long, short
%c	One character
%s	A string (char array ending in '\0')
%f	float or double in printf; float in scanf
%lf	double in scanf (also accepted by printf since C99)
%Lf	long double
%e, %g	%e scientific notation; %g uses %e or %f depending on the exponent and drops trailing zeros
%x/%X, %o	Hexadecimal, octal
%p	A pointer (address)
%zu	size_t, the type of sizeof (C99)
%%	A literal % sign

Facts that exams ask:

• %d and %i are the same in printf. In scanf they differ: %i also reads octal and hex prefixes, so typing 012 gives 10 with %i but 12 with %d, and 0x1A gives 26 with %i.
• scanf needs addresses: scanf("%d", &x);. An array name is already an address, so char name[10]; scanf("%s", name); takes no &.
• printf returns the number of characters it printed, and scanf returns the number of items it read successfully (or EOF). So if (printf("0")) i = 5; else i = 3; printf("%d", i); prints 05: printf printed one character and returned 1 (true).
• A number printed with %c shows the character with that code: printf("%c", 100); prints d, and with int x = 107; char y = 'Q';, printf("%c%d", x, y); prints k81.
• Width and precision: %5d → 42 (right-aligned in 5 places), %-5d → 42 , %05d → 00042, %.2f of 3.14159 → 3.14, %8.3f of 3.14159 → 3.142 (rounded).
• getchar()/putchar() read and write one character. gets() was removed in C11 because it cannot limit input; use fgets().
• Java prints with System.out.println(...) or System.out.printf("%d%n", x) and reads with Scanner (nextInt()); Python uses print(...) and input(), which always returns a string (int(input()) for a number).

7. Increment and decrement

Form	Effect	Value of the expression
++x (prefix)	x increases by 1 first	The new value
x++ (postfix)	x increases by 1 afterwards	The old value
--x, x--	The same, decreasing	New / old value

Trace int a = 5, b = a++ * 2, c = ++a * 2; (each initializer is finished before the next starts):

1. b = a++ * 2 uses the old a (5), so b = 10; then a = 6.
2. c = ++a * 2 makes a = 7 first, so c = 14.

Result: a = 7, b = 10, c = 14. Other rules:

• sizeof does not evaluate its operand. int i = 12; int j = sizeof(i++); leaves i at 12; printing i, j gives 12 4.
• ++ and -- need a variable (an lvalue): 5++ and ++(a + b) do not compile.
• c + 1 >= c does not change c; c++, c = c + 1 and c += 1 all do.
• Java: int C = 10; System.out.println(C--); prints 10 (the old value), then C is 9. Python has no ++ operator; write x += 1.

8. Find-the-output questions, and when there is no answer

Most questions in this chapter show a short program and ask for its output. Work in this order:

1. Write down every variable with its starting value, and its type (watch for char, unsigned and float).
2. Evaluate each expression by precedence, then associativity; do integer division and % exactly.
3. Apply side effects (++, --, assignments) at the right moment, and remember short-circuiting.
4. Copy the format string exactly: a space, a comma or a \n in it appears in the output; a missing space joins numbers.

Worked example 3: exact spacing.

int i = 4;
printf("%d %d", +1, i++);
printf("%d", i++);

1. +1 is just the number 1 (unary plus), and i++ gives 4, then i becomes 5.
2. The first printf prints 1 4.
3. The second prints the old i, 5 (then i becomes 6). Its format has no leading space.

The exact output is 1 45; the keyed option "1 4 5" is that answer written with spaces.

When the C standard gives no answer. If a program modifies a variable twice, or modifies it and also reads it for any purpose other than computing the new value, and the two are unsequenced (no sequence point between them), its behaviour is undefined (C11 6.5p2): the standard allows any result, and different compilers (or optimisation levels) really do differ. i = i + 1 is fine; i = i++ and a[i] = i++ are not. gcc with -Wall warns: "operation on 'i' may be undefined".

Code	Status in C	What to answer
i++ + ++i	Undefined behaviour	"Undefined". (In Java it is well defined: left to right, so with i = 5, i = i++ + ++i gives 12.)
printf("%d%d", ++i, i++)	Undefined (i changed twice among the arguments)	"Undefined". Keys that say 64… for i = 4 assumed the arguments were evaluated right to left.
++z + y - 1 - y + z + x++	Undefined (z is changed and read separately)	With x = y = z = 5 (as in the paper), a keyed 16 assumes ++z happens before the later z is read (6 + 5 − 1 − 5 + 6 + 5); the standard does not promise this, and the other order gives 15.
int i = i++;	Undefined (reads an uninitialized i and modifies it)	"Garbage value / undefined"
x = x++; and a[i] = i++;	Undefined	(In Java, x = x++ leaves x unchanged.)
f() + g()	Unspecified, not undefined: either function may run first	"Cannot be predicted" (for example, which of func3(6) - func2(4,5) / func1(1,2,3) is called first)
INT_MAX + 1	Undefined (signed overflow)	Unsigned arithmetic wraps; signed does not have to.

In an MCQ, choose "undefined behaviour" or "compiler dependent" whenever it is an option. If it is not, the key almost always assumes one particular compiler's order, so pick the option that order produces and expect the question may be contested.

Two more traps from real papers:

• print 9//2 is Python 2 syntax. In Python 3 it is a SyntaxError (print is a function: print(9//2) prints 4). Keys usually give 4, reading the question as "what is 9//2".
• register static int i = 10; does not compile: a declaration may have only one storage-class specifier. And you cannot take the address (&) of a register variable.