Modular programs: contracts aur builds
Clear invariant, private validation, failure behavior aur correct rebuild dependencies wala small score module design karein.
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.
- Input
- Candidate integer aur score pointer
- Success
- Valid score store; true return
- Failure
- False return; previous state preserve
2. Public interface small rakhein
#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
#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
#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 -std=c17 -Wall -Wextra main.c score.c -o score_demo
./score_demo
| Change | Typical rebuild consequence |
|---|---|
| Sirf score.c implementation change | score.c recompile aur executable relink; unchanged clients often object files reuse kar sakte hain. |
| score.h interface change | Changed header ke dependent sources, including implementation aur clients, recompile karke relink karein. |
| Compiler options, target ya generated configuration change | Source 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
- WG14 N1570 — public C11 committee draft: 6.2.2, 6.2.7, 6.9. C17 baseline ke stable core rules ke liye; final ISO publication nahi.
- GNU make: rules and prerequisites
- GCC: dependency generation options
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.
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.
Har choice ki explanation padhein
- Interface header include karna saari definitions automatically supply karta hai.
Header declarations function bodies automatically link nahi karti.
- Caller ko function ka type guess karna chahiye.
Interface check karne ke liye consistent declaration chahiye.
- 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.