Read input.
Control the flow.

UNIT 02 · 01

Tell C what to read. Choose how to display it.

printf() writes formatted output to standard output. scanf() converts input from standard input and stores it in objects. Both are declared in <stdio.h>. Their first argument is a format string (also called a control string): ordinary characters plus conversion specifications beginning with %.

printf("Roll: %d, marks: %.2f\n", roll, marks);
scanf("%d %lf", &roll, &marks);

In printf, pass values. In scanf, pass addresses of objects with the correct types. The & operator supplies an address; a character array already converts to a pointer to its first element. A mismatched conversion and argument can cause undefined behaviour.

Width, precision and successful input

• %6d uses a minimum width of six characters; %06d pads with zeros. Width does not cut off a longer result.
• %.2f displays two digits after the decimal point. %8.2f combines width and precision; %-8.2f aligns left.
• scanf returns the number of successful assignments. Check it before using the variables: if (scanf("%d %lf", &roll, &marks) != 2).
• For char name[20], use scanf("%19s", name) to leave room for the final null character. This reads one word, not a full name with spaces.
• Most conversions skip leading whitespace. %c does not. Use " %c" to skip whitespace before reading a non-whitespace character.
• Whitespace in a scanf format matches any amount of input whitespace. A trailing \n can keep interactive input waiting for another non-whitespace character; it is not a command to read exactly one newline.

42

#include <stdio.h>
int main(void)
{
    int roll;
    double marks;
    if (scanf("%d %lf", &roll, &marks) != 2) {
        puts("Enter a roll number and marks.");
        return 1;
    }
    printf("Roll: %03d\n", roll);
    printf("Marks: %.2f\n", marks);
    printf("Completion: 100%%\n");
    return 0;
}

#include <stdio.h>
int main(void)
{
    int count;
    char code;
    if (scanf("%d", &count) != 1 || scanf(" %c", &code) != 1) {
        puts("Enter a count and a character.");
        return 1;
    }
    /* The space before %c skips whitespace, including newline. */
    printf("Count = %d\nCode = %c\n", count, code);
    return 0;
}

Escape sequences

An escape sequence represents a character within a string or character constant. It is interpreted by C before the library handles the string. %% is a printf conversion, not a backslash escape.

UNIT 02 · 02

One character. One line.

“Unformatted” I/O transfers characters or strings without conversion specifications. These functions also belong to <stdio.h>.

#include <stdio.h>
int main(void)
{
    int ch = getchar();
    if (ch == EOF) {
        puts("No character was supplied.");
        return 1;
    }
    printf("Character: ");
    putchar(ch);
    putchar('\n');
    return 0;
}

#include <stdio.h>
#include <string.h>
int main(void)
{
    char line[40];
    if (fgets(line, sizeof line, stdin) == NULL) {
        puts("No line was supplied.");
        return 1;
    }
    /* Remove the newline if fgets stored one. */
    line[strcspn(line, "\n")] = '\0';
    puts("You typed:");
    puts(line);
    return 0;
}

UNIT 02 · 03

Calculate a value. Test a condition.

Operators act on operands to produce values. Integer and floating-point operands can produce different results even with the same operator.

Conditions treat zero as false and any nonzero value as true. Relational, equality and logical operators return int values 0 or 1. The remainder operator % requires integer operands. Division or remainder by zero is undefined; signed overflow is also undefined. For integer division, C99 and later truncate toward zero; C90 had implementation-defined rounding when a operand was negative. Our introductory arithmetic example uses nonnegative values.

Short-circuit evaluation

&& evaluates its right operand only if its left operand is true. || evaluates its right operand only if its left operand is false. This allows a guard such as b != 0 && a / b > 2. Bitwise & and | do not provide this guard.

#include <stdio.h>
int main(void)
{
    int a, b;
    if (scanf("%d %d", &a, &b) != 2 || a < 0 || a > 100 || b < 1 || b > 100) {
        puts("Enter a from 0 to 100 and b from 1 to 100.");
        return 1;
    }
    printf("Add = %d\n", a + b);
    printf("Subtract = %d\n", a - b);
    printf("Multiply = %d\n", a * b);
    printf("Integer division = %d\n", a / b);
    printf("Remainder = %d\n", a % b);
    printf("Floating division = %.2f\n", (double)a / b);
    return 0;
}

#include <stdio.h>
int main(void)
{
    int a, b;
    if (scanf("%d %d", &a, &b) != 2 || a < 0 || a > 100 || b < 0 || b > 100) {
        puts("Enter two integers from 0 to 100.");
        return 1;
    }
    printf("a > b: %d\n", a > b);
    printf("a == b: %d\n", a == b);
    printf("Both positive: %d\n", a > 0 && b > 0);
    printf("At least one positive: %d\n", a > 0 || b > 0);
    printf("a is zero: %d\n", !a);
    /* If b is zero, && skips a / b. */
    printf("Safe quotient exceeds 2: %d\n", b != 0 && a / b > 2);
    return 0;
}

UNIT 02 · 04

Change the variable. Track the result.

= stores a value; == compares values. Compound assignment combines an operation and assignment: x += 3 adds three to x. More generally, the left operand of a compound assignment is evaluated once, which matters when it is a complex expression.

#include <stdio.h>
int main(void)
{
    int x = 5;
    printf("Start: %d\n", x);
    x += 3; printf("After += 3: %d\n", x);
    x *= 2; printf("After *= 2: %d\n", x);
    x -= 1; printf("After -= 1: %d\n", x);
    x /= 3; printf("After /= 3: %d\n", x);
    x %= 2; printf("After %%= 2: %d\n", x);
    return 0;
}

Prefix and postfix

Both ++ and -- change a modifiable operand by one. Prefix produces the updated value; postfix produces the old value and updates the operand. When used as a statement by itself, ++x; and x++; have the same final effect on x.

#include <stdio.h>
int main(void)
{
    int x = 5, value;
    value = x++;
    printf("Postfix: old = %d, x = %d\n", value, x);
    value = ++x;
    printf("Prefix: new = %d, x = %d\n", value, x);
    value = x--;
    printf("Post-decrement: old = %d, x = %d\n", value, x);
    value = --x;
    printf("Pre-decrement: new = %d, x = %d\n", value, x);
    return 0;
}

UNIT 02 · 05

Look at the individual bits.

Bitwise operators work with integer operands. & keeps a bit when both inputs have it; | keeps it when either has it; ^ keeps it when the inputs differ. ~ complements bits, while << and >> shift positions.

Use unsigned operands for simple bit operations. A shift count must be nonnegative and less than the width of the promoted left operand. Signed left shifts can be undefined; right-shifting a negative signed value is implementation-defined in the C versions covered here. The example masks a complement with 255U to display only the low eight bits.

#include <stdio.h>
int main(void)
{
    unsigned int a, b;
    if (scanf("%u %u", &a, &b) != 2 || a > 255U || b > 255U) {
        puts("Enter two unsigned values from 0 to 255.");
        return 1;
    }
    printf("AND = %u\n", a & b);
    printf("OR = %u\n", a | b);
    printf("XOR = %u\n", a ^ b);
    printf("NOT a (low 8 bits) = %u\n", (~a) & 255U);
    printf("Left shift by 1 = %u\n", a << 1);
    printf("Right shift by 1 = %u\n", a >> 1);
    return 0;
}

UNIT 02 · 06

Select, convert and inspect.

The conditional operator has three operands: condition ? value_if_true : value_if_false. It evaluates the condition and only the selected second or third operand. Compatible operand types determine the result type; it is an expression, so its value can be assigned or printed.

#include <stdio.h>
int main(void)
{
    int a, b, maximum;
    if (scanf("%d %d", &a, &b) != 2) {
        puts("Enter two integers.");
        return 1;
    }
    maximum = a > b ? a : b;
    printf("Maximum = %d\n", maximum);
    return 0;
}

A comma between function arguments or declarations is a separator, not the comma operator. Parentheses around (x = 6, x + 2) group a comma expression. Pointer, array and structure operations will be developed in later units.

#include <stdio.h>
int main(void)
{
    int x = 4, y;
    int *p = &x;
    y = (x = 6, x + 2);
    printf("x = %d, y = %d, *p = %d\n", x, y, *p);
    printf("Object has storage: %d\n", sizeof x > 0);
    printf("Floating division = %.1f\n", (double)5 / 2);
    return 0;
}

UNIT 02 · 07

Group correctly before you calculate.

Precedence decides how different operators group. Associativity decides grouping when operators share a precedence level. Parentheses explicitly group a subexpression. The table lists C90 operators from higher to lower precedence; context distinguishes unary * from multiplication and unary & from bitwise AND.

2 + 3 * 4 groups as 2 + (3 * 4). 10 - 3 - 2 groups as (10 - 3) - 2. a = b = 7 groups as a = (b = 7), setting both to seven.

UNIT 02 · 08

Choose the next path.

An if executes its body when an expression compares unequal to zero. An if-else selects one of two bodies. An else if ladder tests conditions in order and takes the first true branch. Nest an if inside another branch when a second decision depends on the first.

if (condition) {
    /* true branch */
} else {
    /* false branch */
}

if (marks >= 80) grade = 'A';
else if (marks >= 60) grade = 'B';
else if (marks >= 40) grade = 'C';
else grade = 'F';

Without braces, an else belongs to the nearest unmatched if. Braces make the intended nesting explicit. A semicolon immediately after if (condition); makes its body an empty statement, a common logic error.

#include <stdio.h>
int main(void)
{
    int marks;
    char grade;
    if (scanf("%d", &marks) != 1 || marks < 0 || marks > 100) {
        puts("Enter marks from 0 to 100.");
        return 1;
    }
    /* Illustrative thresholds, not a university grading policy. */
    if (marks >= 80) grade = 'A';
    else if (marks >= 60) grade = 'B';
    else if (marks >= 40) grade = 'C';
    else grade = 'F';
    printf("Grade = %c\n", grade);
    return 0;
}

UNIT 02 · 09

Select a case. Leave or skip a step.

switch evaluates an integer expression and transfers control to a matching case label. Labels use unique integer constant expressions, such as case 1: or case 'A':. A default label handles unmatched values and is optional.

A switch does not automatically stop at the next label. Execution falls through unless a jump such as break or return exits. Cases cannot directly match string values or floating-point values. For ranges, use an if-else ladder.

#include <stdio.h>
int main(void)
{
    int choice;
    if (scanf("%d", &choice) != 1) {
        puts("Enter an integer menu choice.");
        return 1;
    }
    switch (choice) {
        case 1: puts("Open the notes"); break;
        case 2: puts("Open the lab"); break;
        case 3: puts("Open the revision questions"); break;
        default: puts("Unknown choice"); break;
    }
    return 0;
}

In a while or do-while loop, continue moves to the condition check; ensure the loop’s state still advances. A break inside a switch nested in a loop leaves the switch, not the surrounding loop. A label has the syntax label: and, in C90, must precede a statement.

#include <stdio.h>
int main(void)
{
    int i, sum = 0;
    printf("Accepted:");
    for (i = 1; i <= 7; i++) {
        if (i == 3) continue;
        if (i > 5) break;
        printf(" %d", i);
        sum += i;
    }
    printf("\nSum = %d\n", sum);
    return 0;
}

#include <stdio.h>
int main(void)
{
    int value;
    if (scanf("%d", &value) != 1) goto invalid;
    if (value <= 0) goto invalid;
    printf("Accepted positive value: %d\n", value);
    return 0;
invalid:
    puts("A positive integer is required.");
    return 1;
}

UNIT 02 · 10

Repeat with a clear stopping condition.

Choose a while when repetition depends on a changing condition, a do-while when one attempt must occur, and a for when initialization, test and update fit naturally together. These are conventions, not restrictions. A for can omit its condition to make it always true; every loop still needs a reachable way to finish when the task requires one.

#include <stdio.h>
int main(void)
{
    int n, i, sum;
    if (scanf("%d", &n) != 1 || n < 0 || n > 10) {
        puts("Enter n from 0 to 10.");
        return 1;
    }
    i = 1; sum = 0;
    while (i <= n) { sum += i; i++; }
    printf("while sum = %d\n", sum);
    i = 1; sum = 0;
    do { sum += i; i++; } while (i <= n);
    printf("do-while sum = %d\n", sum);
    sum = 0;
    for (i = 1; i <= n; i++) { sum += i; }
    printf("for sum = %d\n", sum);
    return 0;
}

Nested loops

A nested loop places one loop inside another. For each outer iteration, the inner loop starts again when its initialization is reached. A rectangular grid with R rows and C columns visits R × C positions; a triangle with N rows prints 1 + 2 + … + N stars. In the triangle program, row is the outer counter and column is the inner counter.

Ready to print.

#include <stdio.h>
int main(void)
{
    int rows, row, column;
    if (scanf("%d", &rows) != 1 || rows < 1 || rows > 6) {
        puts("Enter rows from 1 to 6.");
        return 1;
    }
    for (row = 1; row <= rows; row++) {
        for (column = 1; column <= row; column++) {
            putchar('*');
        }
        putchar('\n');
    }
    return 0;
}

A quick loop checklist

• Initialize every counter and accumulator before reading it.
• Check boundary values: zero iterations, one iteration, and the last iteration.
• Update the state on every repeating path, including paths using continue.
• Use < versus <= deliberately; dry-run the final counter value.
• Do not place an unintended semicolon after a loop header.

UNIT 02 · 11

Edit it. Run it. Explain it.

Choose an example and load it into the embedded C compiler. Select I/O inside the compiler, check the sample STDIN, and press Run. Change the input or edit the source to explore a different case.

7 85.5

Roll: 007
Marks: 85.50
Completion: 100%

#include <stdio.h>
int main(void)
{
    int roll;
    double marks;
    if (scanf("%d %lf", &roll, &marks) != 2) {
        puts("Enter a roll number and marks.");
        return 1;
    }
    printf("Roll: %03d\n", roll);
    printf("Marks: %.2f\n", marks);
    printf("Completion: 100%%\n");
    return 0;
}

Experiments to try

• Arithmetic: compare inputs 7 2 and 8 2. Explain the integer quotient and remainder.
• Logical: use 8 0. Why does the guarded division remain safe?
• Grade: test 39, 40, 59, 60, 79 and 80. Explain each boundary.
• Switch: try choice 9, then remove one break and inspect fall-through.
• Loops: use N = 0 and N = 1. Add a guard to the do-while version and compare.
• Nested loops: change the inner condition from column <= row to column <= rows to print a square.

UNIT 02 · 12

Finish with a self-check.

Written exam practice

1. Explain printf and scanf with control strings, field width, precision and suitable examples.
2. Describe escape sequences and distinguish formatted and unformatted I/O.
3. Explain getchar, putchar, gets and puts; show a bounded replacement for gets.
4. Classify C operators and explain integer division, logical short-circuiting and bitwise operations.
5. Distinguish prefix and postfix increment with a dry run of separate statements.
6. Explain precedence and associativity; evaluate a parenthesized arithmetic expression.
7. Write an if-else ladder and a switch program; explain fall-through and break.
8. Compare goto, break and continue with their scope and effects.
9. Compare while, do-while and for using N = 0 and N = 3 as test cases.
10. Write a nested-loop triangle program and trace row and column values.

UNIT 02 · 13

Read alongside your textbook.

E. Balagurusamy, Programming in ANSI C, Eighth Edition, McGraw Hill Education (India) Private Limited. ISBN 9789353165130.

Use your copy for the chapters on operators and expressions, input/output, decision making and looping. These original notes and programs follow the supplied Unit 2 syllabus; they do not reproduce the book’s chapter text or claim page-by-page correspondence. Runnable examples use portable C90 syntax, with later-standard differences identified where relevant.

• Book edition details
• WG14 C11 committee draft: expressions, statements and stdio
• GNU C reference: order of execution
• OneCompiler editor documentation