YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Sahi aur reliable CChapter 67 of 73

Style, contracts aur code review

Names, invariants, scope, control flow, guidelines aur review se assumptions visible banayein.

5 min readIntermediateC17 baseline
Offline reading
Is chapter mein8 sections
0% through this chapter

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

Complete C17 program
#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

Complete C17 program
#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

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.
Apne words mein samjhaayein

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.

Kya clear naming aur indentation ownership contract replace kar sakte hain?
Har choice ki explanation padhein
  1. Haan, formatting resources automatically release karti hai.

    Formatting runtime cleanup nahi karti.

  2. 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.

  3. 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 switch mein ek default case 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.

CHAPTER 67 / 73

Is chapter mein

Style, contracts aur code review

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