YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Program bananaChapter 45 of 73

Modular programs: contracts aur builds

Clear invariant, private validation, failure behavior aur correct rebuild dependencies wala small score module design karein.

5 min readIntermediateC17 baseline
Offline reading
Is chapter mein8 sections

Bada program tab clear hota hai jab har part ki responsibility clear ho. Modules details hide karke chhota interface share kar sakte hain. Is design ko declarations, private helpers aur rebuild dependencies se jodenge.

1. Responsibility aur invariant se start karein

Invariant woh condition hai jo design defined boundaries par preserve karna chahta hai. Yahan score zero se hundred tak integer hai. Module candidate value accept karke check karta hai aur sirf success par existing score change karta hai. Transfer karne ke liye allocation ownership nahi. Complex module resource lifetime, borrowing aur cleanup bhi specify karega.

Small module contract
Input
Candidate integer aur score pointer
Success
Valid score store; true return
Failure
False return; previous state preserve
Non-null pointer live writable score object designate kare. Null pointer rejected request ki tarah handle hota hai.

2. Public interface small rakhein

C17 · project file · score.h
#ifndef CODEDILE_SCORE_H
#define CODEDILE_SCORE_H

#include <stdbool.h>

struct CodedileScore { int points; };
/* Accept 0..100. On failure, leave a non-null score unchanged. */
bool codedile_score_set(struct CodedileScore *score, int points);

#endif

Header structure expose karta hai taaki caller directly object create kar sake. Representation interface ka part ban jaati hai: caller khud invalid member value bhi write kar sakta hai. Isliye design documented caller discipline par rely karta hai; har possible write ke against invariant enforce nahi karta. Earlier data-interface lesson ka opaque type stronger control ke liye representation hide kar sakta hai.

3. Implementation choices interface ke peeche rakhein

C17 · project file · score.c
#include "score.h"
#include <stddef.h>

static bool valid_points(int points)
{
    return points >= 0 && points <= 100;
}

bool codedile_score_set(struct CodedileScore *score, int points)
{
    if (score == NULL || !valid_points(points)) return false;
    score->points = points;
    return true;
}

Private helper accepted range ek jagah express karta hai. Uske static function identifier ki internal linkage hai. Public function write se pehle validate karta hai, isliye rejected request previous state unchanged chhodti hai. Pehle write karke later previous value recover karne ki hope na rakhein. Public header include karne se conflicting implementation signature compiler ko visible hoti hai.

4. Boundary test karein, rejection bhi

C17 · project file · main.c
#include "score.h"
#include <assert.h>
#include <stddef.h>

int main(void)
{
    struct CodedileScore score = { .points = 0 };
    bool accepted = codedile_score_set(&score, 73);
    assert(accepted && score.points == 73);
    bool rejected = codedile_score_set(&score, 101);
    assert(!rejected && score.points == 73);
    bool null_rejected = codedile_score_set(NULL, 10);
    assert(!null_rejected);
    return 0;
}

Client accepted value, out-of-range value aur null request check karta hai. Checks public behavior ko target karte hain, helper implementation ko nahi. Object valid state se start hota hai. Arbitrary non-null pointer ko sirf NULL se compare karna validate nahi karta; caller type, lifetime, alignment aur writability guarantee karta hai.

Module mein synchronization nahi aur same score ke concurrent access ka safety promise nahi. Files ya static helpers add karne se thread safety nahi aati. Later shared concurrent state chahiye toh interface aur implementation ko synchronization contract explicitly define karna hoga.

5. Build dependencies record karti hai, sirf filenames nahi

Small project mein GCC driver dono source files compile aur single invocation mein link kar sakta hai. Suitable Unix-like shell mein files ke folder se example commands run karein. Successful run ka output nahi; assertions-enabled build mein failed expectation assertion report karegi.

GCC / GNU tools · example commands
gcc -std=c17 -Wall -Wextra main.c score.c -o score_demo
./score_demo
ChangeTypical rebuild consequence
Sirf score.c implementation changescore.c recompile aur executable relink; unchanged clients often object files reuse kar sakte hain.
score.h interface changeChanged header ke dependent sources, including implementation aur clients, recompile karke relink karein.
Compiler options, target ya generated configuration changeSource text same ho tab bhi affected object files rebuild chahiye ho sakti hain.

Make jaise build tools targets aur prerequisites track karte hain. Compiler-generated dependency information indirect headers include karke stale-build mistakes kam kar sakti hai. Dependency setup check karte waqt clean rebuild useful hai, lekin har baar sab rebuild karna correct dependency records ka substitute nahi. Generated files, compile options aur required libraries reproducible build description mein rakhein.

Primary references aur aage ki reading

Aage badhne se pehle

  • Module ki coherent responsibility aur clear interface honi chahiye.
  • Private representation aur helpers se doosre code ko kam state samajhni padti hai.
  • Build dependencies mein implementation files ke saath shared interface changes bhi aane chahiye.
In ideas ko alag rakhein
Private representation / Unrestricted safety
Data hide karne se valid operations control hoti hain; implementation ko invariant aur failure handling phir bhi chahiye.
Apne words mein samjhaayein

Doosre programmer ko module ke accepted inputs aur rejection par unchanged policy kaise describe karenge?

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.

Ordinary two-file module build mein interface aur implementation kaise supply hote hain?
Har choice ki explanation padhein
  1. Interface header include karna saari definitions automatically supply karta hai.

    Header declarations function bodies automatically link nahi karti.

  2. Caller ko function ka type guess karna chahiye.

    Interface check karne ke liye consistent declaration chahiye.

  3. Header se declarations share karein aur implementation source build mein dein.

    ✓ Sahi reasoning. Build ko program ki required definitions translate aur connect karni hoti hain.

C17

Earlier edition ka quick reference

Existing section links aur saved passages ke liye retained. Expanded explanation upar hai; documented corrections source review mein recorded hain.

Real C programs rarely ek single file hoti hain. Conventional pattern har logical module ko ek header (.h, declarations) aur ek source file (.c, definitions) mein split karta hai, jisse doosri files uss module ko use karne ke liye header #include kar sakti hain, bina har caller mein uski function bodies ki zaroorat ke. Interface aur dependency changes par affected source files ko rebuild karna phir bhi zaroori ho sakta hai. Compiler har .c file ko independently ek object file (.o) mein translate karta hai; phir linker saare object files, plus koi bhi zaroori libraries, ko combine karke final executable banata hai, har function ya variable reference ko uski actual definition se resolve karte hue.

In compilation commands ko haath se type karne ke bajaye, zyadatar nontrivial projects ek build tool use karte hain — traditionally make, jo ek Makefile se driven hota hai jo specify karti hai ki kaunsi files kis par depend karti hain — taaki jin targets ki prerequisites badli hain unhe rebuild kiya jaaye; header badalne par unchanged source file ko bhi recompile karna pad sakta hai. Reusable code ko ek library ke roop mein bhi package kiya ja sakta hai: ek static library (Unix par .a, Windows par .lib) se linker link time par normally needed object members select karta hai, jabki ek dynamic/shared library (.so, .dll) runtime par load hoti hai aur ek saath multiple running programs ke beech memory mein share ho sakti hai.

Agla idea padhne ke liye tayyar?

Mark this chapter as read whenever you feel ready.

CHAPTER 45 / 73

Is chapter mein

Modular programs: contracts aur builds

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