YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
C ka contextChapter 72 of 73

Complete programs ko contracts se samjhein

Do worked C17 programs se validation, objects, arithmetic, state changes aur output connect karein.

7 min readIntermediateC17 synthesis
Offline reading
Is chapter mein9 sections

Complete program kai chhote rules jodta hai. Padhte waqt poochhein: allowed inputs kya hain, har step kya change karta hai aur failure kaise report hoti hai? Yahan examples theory jodte hain; Codeweek longer line-by-line practice deta hai.

1. Program ko chaar passes mein padhein

  1. Job state karein. Accepted input aur required result identify karein.
  2. Data contract banayein. Live objects, accessible regions, ownership aur permitted mutation name karein.
  3. Decisions/updates follow karein. Operation validation par rely kare usse pehle check hona chahiye.
  4. Failure/cleanup follow karein. Rejection par kya state bachegi aur kya acquired resource release hoga, explain karein.

Successful demonstration sirf checked case confirm karti hai. Har input, implementation, schedule ya environment prove nahi hota. Contract example ke paas rakhein taaki ek assumption change karna reasoning silently invalidate na kare.

2. Sum jo success par hi result commit karta hai

Complete C17 program
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <limits.h>

static bool sum_values(const unsigned *values, size_t count,
                       unsigned *result)
{
    if (result == NULL || (values == NULL && count != 0)) return false;
    unsigned total = 0;
    for (size_t i = 0; i < count; ++i) {
        if (values[i] > UINT_MAX - total) return false;
        total += values[i];
    }
    *result = total;
    return true;
}

int main(void)
{
    const unsigned values[3] = { 10, 20, 30 };
    unsigned result = 999;
    bool accepted = sum_values(values, 3, &result);
    assert(accepted && result == 60);

    const unsigned too_large[2] = { UINT_MAX, 1 };
    result = 77;
    bool rejected = sum_values(too_large, 2, &result);
    assert(!rejected && result == 77);

    bool empty = sum_values(NULL, 0, &result);
    assert(empty && result == 0);
    bool absent_input = sum_values(NULL, 1, &result);
    assert(!absent_input && result == 0);
    bool absent_result = sum_values(values, 3, NULL);
    assert(!absent_result);
    return 0;
}

Input count readable unsigned objects ka region hai, ya count zero hone par null pointer. Result live writable unsigned destination designate karta hai. Function input borrow karta hai; region allocate/free nahi karta. Pointer type aur null check caller ki real region length prove nahi kar sakte.

Total zero se shuru hai. Values[i] add karne se pehle comparison mathematical result ko unsigned mein fit prove karta hai. Unsigned wrap defined hota, lekin application intended sum ka loss reject karti hai. Result loop ke baad write hota hai, isliye overflow rejection previous destination value preserve karti hai.

Program normal sum, sentinel result ke saath overflow rejection, empty region, missing nonempty input aur missing result check karta hai. Calls assert se pehle hain; assertions disable karne se demonstrated operation remove nahi hona chahiye. Individual rules ke liye operators, array/count contracts aur defensive boundaries dekhein.

3. Explicit grammar wala small input workflow

Application ek command-line argument accept karti hai: ek se teen decimal digits, value 0 se 100. Length limit ke andar leading zeroes allowed; signs, whitespace, trailing text aur longer spellings reject hain. Yeh application policy hai, strtol ke saare accepted strings ka description nahi.

Complete C17 workflow padhein
Complete C17 program
#include <errno.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

static bool parse_level(const char *text, int *result)
{
    if (text == NULL || result == NULL || text[0] == '\0') return false;
    size_t length = 0;
    for (; text[length] != '\0'; ++length) {
        if (length == 3 || text[length] < '0' || text[length] > '9') {
            return false;
        }
    }
    errno = 0;
    char *end;
    long candidate = strtol(text, &end, 10);
    if (errno == ERANGE || *end != '\0' || candidate < 0 || candidate > 100) {
        return false;
    }
    *result = (int)candidate;
    return true;
}

int main(int argc, char *argv[])
{
    if (argc != 2) {
        fputs("Usage: level VALUE\n", stderr);
        return EXIT_FAILURE;
    }
    int level = 0;
    if (!parse_level(argv[1], &level)) {
        fputs("Use one to three digits, with value 0 through 100.\n", stderr);
        return EXIT_FAILURE;
    }
    if (printf("level=%d\n", level) < 0 || fflush(stdout) == EOF) {
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

parse_level missing destination/empty text reject karke spelling aur length validate karta hai. Grammar establish hone ke baad conversion, status aur domain check hoti hai; 0 se 100 prove hone ke baad hi int conversion hai. Destination sirf acceptance par ek baar change hota hai. Source contract valid null-terminated string require karta hai; arbitrary dangling pointer ko safely inspect nahi kar sakta.

Main argv[1] use karne se pehle argc check karta hai. Input errors stderr par aur failure status select karte hain. Accepted input labelled value produce karta hai; required output check/flush hota hai. Successful flush host-stream observation hai, external destination ki physical durability guarantee nahi.

ArgumentDecisionReason
42Accept: level=42Grammar, length aur domain valid hain.
001Accept: level=1Leading zeroes allowed; base 10 explicit hai.
101RejectDigit spelling valid, application range se bahar.
+1 ya 1 ke baad letterRejectGrammar general strtol syntax se narrower hai.
0000RejectValue akeli three-character spelling limit satisfy nahi karti.

Har boundary ke liye command-line arguments, parsing aur output contracts revisit karein. Larger application diagnostics/policy aur separate kar sakti hai; small program unhe visible rakhta hai.

4. Ek assumption change karke connected rules recheck karein

Sum signed negative values accept kare toh unsigned-domain proof required proof nahi rahega. Input format spaces ya larger range allow kare toh grammar, conversion/range checks, diagnostics aur examples saath change honge. Buffers threads ke beech shared hon toh const akela synchronize nahi karega.

Allocating variant mein returned storage ka owner aur exact release operation define karein. File variant mein acquisition, transfer, close aur partial-output behavior review karein. Yeh connected design decisions hain; cast add ya warning suppress karke fill nahi hote.

5. Earlier example collection ko kaise use karein

Retained collection mein nau complete programs hain: greeting, arithmetic, FizzBuzz, bounded factorial, arrays, linked list, growing allocation, controlled file I/O aur macros. Stated limits ke saath illustrations ki tarah padhein. Factorial small n ke liye hai; file reader same example se generated small integers read karta hai; macros described simple arguments ke liye hain.

Adapt karte waqt allocation/ownership, cleanup aur macro limitations dekhein. Demonstrations pass hone se arbitrary external files ka robust parser, unbounded recursion policy ya generally hygienic swap macro establish nahi hota.

6. Thought check: output aur explanation

Sum predict kar liya. Function adapt karne se pehle aur kya explain karna chahiye?

Input region/count aur lifetime, destination validity, numeric domain/overflow proof, aliasing/mutation policy, rejection behavior aur thread assumptions state karein. Output us contract ke andar ek observation hai.

Sources aur aage ki reading

Aage badhne se pehle

  • Complete program kai object, control-flow aur interface contracts jodta hai.
  • Success, rejection aur cleanup paths sab promised behavior ka part hain.
  • Boundary cases reasoning test karte hain; har possible execution prove nahi karte.
In ideas ko alag rakhein
Observed output / Explained behavior
Output ek case ka evidence hai; explanation use types, state changes, bounds aur contracts se jodti hai.
Apne words mein samjhaayein

Ek complete example choose karke batayein ki invalid input reject hone par kya unchanged rehta hai.

Optional: bolkar samjhein ya note rakhein. Tayyar hon toh aage badh sakte hain.

Apni understanding check karein

Optional hai. Answers save ya send nahi hote; chapter kabhi lock nahi hota.

Complete example ek baar expected output deta hai. Ab kya examine karein?
Har choice ki explanation padhein
  1. Uski input assumptions, boundaries, failures aur resource handling.

    ✓ Sahi reasoning. Observed output bade contract ke baare mein evidence ka ek part hai.

  2. Sirf variable names doosre example se match karte hain ya nahi.

    Sirf names equivalent behavior establish nahi karte.

  3. Kuch nahi; ek output har execution prove karta hai.

    Different inputs aur paths different conditions exercise kar sakte hain.

General

Earlier edition ka quick reference

Existing section links aur saved passages ke liye retained. Exact corrections source review mein documented hain.

Neeche diye gaye short, self-contained programs upar diye gaye concepts ko practice mein laate hain. Code khud unchanged hai — jaisa yeh actually C mein likha aur compile hota hai — sirf labels aur explanations Hinglish mein hain.

Hello, World

C17 · illustrative fragment
#include <stdio.h>
int main(void) {
    printf("Hello, World!\n");
    return 0;
}

Variables aur Arithmetic

C17 · illustrative fragment
#include <stdio.h>
int main(void) {
    int a = 7, b = 3;
    printf("Sum: %d, Product: %d, Quotient: %.2f\n",
           a + b, a * b, (double)a / b);
    return 0;
}

Control Flow

C17 · illustrative fragment
#include <stdio.h>
int main(void) {
    for (int i = 1; i <= 20; i++) {
        if (i % 15 == 0)      printf("FizzBuzz\n");
        else if (i % 3 == 0)  printf("Fizz\n");
        else if (i % 5 == 0)  printf("Buzz\n");
        else                  printf("%d\n", i);
    }
    return 0;
}

Recursion

C17 · illustrative fragment
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

/* Returns 0 for an invalid argument or a result too large for long.
   This teaching example uses small n; very deep recursion can exhaust resources. */
long factorial(int n) {
    if (n < 0) return 0;
    if (n <= 1) return 1;
    long partial = factorial(n - 1);
    if (partial == 0 || partial > LONG_MAX / n) return 0;
    return n * partial;
}

int main(void) {
    long result = factorial(5);
    if (result == 0) {
        fputs("Invalid argument or factorial overflow\n", stderr);
        return EXIT_FAILURE;
    }
    printf("5! = %ld\n", result);
    return EXIT_SUCCESS;
}

Arrays aur Pointer Arithmetic

C17 · illustrative fragment
#include <stdio.h>
int main(void) {
    int arr[5] = {10, 20, 30, 40, 50};
    int *p = arr;                /* array apne pehle element, arr[0], ke pointer mein decay ho jaata hai */
    for (int i = 0; i < 5; i++) {
        printf("%d ", *(p + i)); /* arr[i] ke equivalent */
    }
    printf("\n");
    return 0;
}

Ek Self-Referential Struct: Singly Linked List

C17 · illustrative fragment
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node *next;
};

int main(void) {
    struct Node *head = malloc(sizeof *head);
    struct Node *second = malloc(sizeof *second);
    if (head == NULL || second == NULL) {
        free(second);
        free(head);
        return EXIT_FAILURE;
    }
    head->data = 1;
    head->next = second;
    second->data = 2;
    second->next = NULL;

    for (struct Node *cur = head; cur != NULL; cur = cur->next) {
        printf("%d -> ", cur->data);
    }
    printf("NULL\n");

    free(second);
    free(head);
    return EXIT_SUCCESS;
}

Ek Dynamic Array Jo realloc Se Grow Hoti Hai

C17 · illustrative fragment
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    size_t capacity = 2, count = 0;
    int *nums = malloc(capacity * sizeof *nums);
    if (nums == NULL) return EXIT_FAILURE;

    for (int i = 0; i < 5; i++) {
        if (count == capacity) {
            if (capacity > SIZE_MAX / 2) {
                free(nums);
                return EXIT_FAILURE;
            }
            size_t new_capacity = capacity * 2;
            if (new_capacity > SIZE_MAX / sizeof *nums) {
                free(nums);
                return EXIT_FAILURE;
            }
            int *tmp = realloc(nums, new_capacity * sizeof *nums);
            if (tmp == NULL) {
                free(nums);
                return EXIT_FAILURE;
            }
            nums = tmp;
            capacity = new_capacity;
        }
        nums[count++] = i * i;  /* i is only 0 through 4 here */
    }
    for (size_t i = 0; i < count; i++) printf("%d ", nums[i]);
    printf("\n");

    free(nums);
    return EXIT_SUCCESS;
}

File Mein Likhna Aur Usse Read Karna

C17 · illustrative fragment
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    FILE *out = fopen("numbers.txt", "w");
    if (out == NULL) return EXIT_FAILURE;
    for (int i = 1; i <= 3; i++) {
        if (fprintf(out, "%d\n", i) < 0) {
            fclose(out);
            return EXIT_FAILURE;
        }
    }
    if (fclose(out) == EOF) return EXIT_FAILURE;

    FILE *in = fopen("numbers.txt", "r");
    if (in == NULL) return EXIT_FAILURE;
    int value;
    int status;
    while ((status = fscanf(in, "%d", &value)) == 1) {
        if (printf("Read: %d\n", value) < 0) {
            fclose(in);
            return EXIT_FAILURE;
        }
    }
    /* This file contains only the small integers written above. */
    int failed = ferror(in) || status != EOF;
    if (fclose(in) == EOF) failed = 1;
    return failed ? EXIT_FAILURE : EXIT_SUCCESS;
}

Sahi Tarah Se Parenthesized Macros

C17 · illustrative fragment
#include <stdio.h>
#define SQUARE(x) ((x) * (x))
#define SWAP(T, a, b) do { T temp = (a); (a) = (b); (b) = temp; } while (0)

int main(void) {
    int a = 4, b = 9;
    printf("SQUARE(2+3) = %d\n", SQUARE(2 + 3));  /* sahi se 25, 11 nahi */
    SWAP(int, a, b);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

Macro limitations: Yeh simple arguments ke examples hain, functions ke general replacements nahi. SQUARE(i++) ab bhi undefined hai; SWAP arguments ko repeatedly evaluate karta hai aur internal naam temp caller ke naam se collide kar sakta hai. Is SWAP mein simple, distinct modifiable lvalues use karein, side effects avoid karein aur practical ho toh typed functions prefer karein.

Agla idea padhne ke liye tayyar?

Mark this chapter as read whenever you feel ready.

CHAPTER 72 / 73

Is chapter mein

Complete programs ko contracts se samjhein

Search all 73 chapters in both languages.EN + HG

Try “pointer”, “why int”, or “undefined behavior”.

Concepts connect. Follow your curiosity.↑ ↓ to explore · Enter to open
MAKE YOURSELF COMFORTABLE

Your reading space

Appearance

A clear canvas with balanced contrast.

Text size

100%
AA

Reading tools

Your data stays in this browser

Export a backup before changing browsers or replacing an older version of the reader.

YOUR PERSONAL MARGINS

My notebook

Saved on this device
A LITTLE CLARITY

The glossary

A starting meaning, then a chapter to go deeper.

A QUICK DEFINITION

A little clarity

Read the full explanation →

A thought worth keeping