Style, contracts aur code review
Names, invariants, scope, control flow, guidelines aur review se assumptions visible banayein.
Is chapter mein8 sections
Readable code doosre person ko aapki reasoning check karne deta hai. Names, chhote interfaces aur visible validation steps se assumptions milna aasaan hota hai. Style choices ko reviewable behavior se jodkar conventions aur language rules alag karenge.
1. Names unit aur responsibility expose karein
Names bytes/elements, capacity/logical length aur candidate/accepted state distinguish karein. Length parameter kya count karta hai, clear ho. Module prefix identifier collisions aur macro prefix preprocessing collisions reduce karta hai. Private-looking underscore names invent karne ke bajay reserved-identifier rules follow karein.
2. Precondition aur update order visible rakhein
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
enum { SCORE_LIMIT = 100 };
struct Score { unsigned points; };
static bool add_points(struct Score *score, unsigned increment)
{
if (score == NULL || score->points > SCORE_LIMIT) return false;
if (increment > SCORE_LIMIT - score->points) return false;
score->points += increment;
return true;
}
int main(void)
{
struct Score score = { .points = 73 };
bool accepted = add_points(&score, 7);
assert(accepted && score.points == 80);
bool rejected = add_points(&score, 30);
assert(!rejected && score.points == 80);
return 0;
}
Named limit domain explain karta hai. First check subtraction se pehle current state establish; second increment ka intended bound prove karta hai. Phir state change hoti hai. Rejected request old value preserve karti hai. Structure exposed hai, isliye function invalid existing points ko reject karta hai, type alone invariant enforce karti hai aisa pretend nahi.
Functions focused rakhein taaki ownership/failure paths review mein fit hon. Small ka matlab har line another helper mein hide karna nahi. Order matter kare toh operations separate, objects use se pehle initialize aur scope needed code ke close rakhein. Comments reason/contract explain karein, assignment ko English mein repeat nahi.
3. Domain ke around control flow likhein
#include <assert.h>
#include <stddef.h>
#include <string.h>
enum Mode { MODE_READ, MODE_WRITE };
static const char *mode_name(enum Mode mode)
{
switch (mode) {
case MODE_READ: return "read";
case MODE_WRITE: return "write";
default: return NULL;
}
}
int main(void)
{
const char *name = mode_name(MODE_READ);
assert(name != NULL && strcmp(name, "read") == 0);
const char *unknown = mode_name((enum Mode)99);
assert(unknown == NULL);
return 0;
}
Is interface mein default unrecognized input handle aur named cases recognized domain document karti hain. C generally har switch mein default ya exhaustive coverage prove karna require nahi karti. Compiler checks/project standards policies add kar sakte hain. Enumerator add karte waqt sirf warning silence nahi, transition/error behavior assess karein.
4. Formatting aur coding standards ke roles different hain
Brace placement, indentation width, line length aur naming team choices hain, jab tak chosen standard rule impose na kare. Formatter mechanical choices consistent bana sakta hai. Ek brace style ko C language requirement na kahein. Large formatting-only changes se meaningful changes separately review karein taaki contracts/behavior visible rahein.
MISRA C aur SEI CERT C distinct guideline families hain, apne scope, editions aur adoption processes ke saath. ISO C conformance ya formatter preset se interchangeable nahi. Adoption ke liye actual applicable text, allowed deviations aur suitable review/tool evidence chahiye; sirf naam cite karna certification nahi.
5. Review data aur failure paths follow karta hai
Input boundary se start karein. Type, range, count, lifetime aur ownership facts kahan establish/use hote hain, poochhein. Early exits/cleanup follow, phir shared-state synchronization examine karein. API ke according required return values check karein; every-ignored-return-is-wrong rule indiscriminately apply na karein. Deliberate target assumptions record aur regression tests se intended contract explain karein.
Expanded Correctness & care unit yahan complete hai. Expanded Language details aur C in context chapters se contracts ko declaration rules aur version choices se connect karein. In reasoning tools se earlier examples revisit karein; chapter read mark karna personal progress marker hai, every advanced contract mastered hone ka claim nahi.
Primary references aur aage ki reading
- WG14 N1570 — public C11 committee draft: 6.2.1, 6.4.2.1, 6.8.4.2, 7.1.3. C17 baseline ke stable core rules ke liye; final ISO publication nahi.
- SEI CERT C: public standard
- MISRA Compliance:2020 — official process guidance
Aage badhne se pehle
- Readable names aur interfaces se assumptions inspect karna aasaan hota hai.
- Validation aur state updates ka deliberate reviewable order hona chahiye.
- Style guidelines language rules aur application contract ko complement karti hain.
In ideas ko alag rakhein
- Consistent formatting / Correct behavior
- Neatly formatted function bhi bounds, lifetime, range ya application requirements tod sakta hai.
Kaunsa naming ya control-flow change function ka rejection path review karna easier banayega?
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
- Haan, formatting resources automatically release karti hai.
Formatting runtime cleanup nahi karti.
- Nahi. Woh contract communicate karte hain, par use design aur follow karna phir bhi zaroori hai.
✓ Sahi reasoning. Readable code reasoning aasaan karta hai; har operation automatically correct nahi banata.
- Haan, descriptive pointer name uski lifetime prove karta hai.
Naam object ke abhi alive hone ka evidence nahi.
General
Earlier edition ka quick reference
Existing section links aur saved passages ke liye retained. Connected ideas expanded lessons mein hain; exact corrections source review mein recorded hain.
Kyunki C ke minimal restrictions individual style ke liye bahut zyada room chhod dete hain, zyadatar serious C codebases ek formal convention adopt karte hain:
- Layout styles. Terse K&R style (opening brace apne statement ki hi line par) Kernighan aur Ritchie ki khud ki book se originate hoti hai; Allman style har brace ko apni khud ki line par rakhti hai; Linux kernel coding style K&R ka ek widely referenced, tab-based variant hai jisme line length aur naming ke strict rules hain.
- Safety-critical standards. MISRA C, jo originally automotive industry ke liye develop hui thi, un constructs ko restrict ya forbid karti hai jo undefined ya hard-to-review behavior ke prone hote hain — jaise, pointer arithmetic ke kuch uses ban karna, ya har
switchmein ekdefaultcase require karna. CERT C ek comparable secure-coding standard hai, jo specifically functional-safety concerns ke bajaye exploitable vulnerabilities eliminate karne par focused hai. - General best practices. Consistent naming aur indentation, unexplained "magic numbers" ke bajaye named constants ya enums use karna, har function ko ek single task par focused rakhna, variables ka scope aur lifetime minimize karna, aur har uss function ka return value check karna jo fail ho sakta hai.
Agla idea padhne ke liye tayyar?
Mark this chapter as read whenever you feel ready.