YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Input ke saath kaamChapter 55 of 73

Errors, status, errno aur assertions

Clear failure outcomes design, errno contracts respect, validation assert se bahar aur nonlocal-jump limits recognize karein.

6 min readIntermediateC17 baseline
Offline reading
Is chapter mein8 sections

Valid operation bhi fail ho sakta hai: input invalid, file missing ya storage unavailable ho sakti hai. Interfaces failures alag ways se report karte hain. Returned status, error information aur program assumptions ke assertions ko alag samjhenge.

1. Har operation ka convention samjhein

OperationInterpretation
fopenNon-null stream / null failure
fgetcCharacter result / EOF; end aur error indicators se distinguish karein
freadComplete elements transferred; short count interpret karein
printfNonnegative character count / negative failure
fseekZero success / nonzero failure
fcloseZero success / EOF failure; stream dono cases mein disassociated
Custom interfaceDocumented status aur useful ho toh separate result

Har API ke liye all-negative-values-are-errors rule invent na karein. Integer result legitimately negative, successful function ka return nonzero aur zero count empty request ho sakta hai. Retry, normal stop, diagnostic ya record rejection decide karne se pehle operation contract follow karein.

2. Status aur useful data separate rakhein

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

enum DivideStatus { DIVIDE_OK, DIVIDE_NO_RESULT, DIVIDE_BY_ZERO, DIVIDE_RANGE } ;

static enum DivideStatus divide_int(int left, int right, int *result)
{
    if (result == NULL) return DIVIDE_NO_RESULT;
    if (right == 0) return DIVIDE_BY_ZERO;
    if (left == INT_MIN && right == -1 && INT_MIN < -INT_MAX) return DIVIDE_RANGE;
    *result = left / right;
    return DIVIDE_OK;
}

int main(void)
{
    int value = 99;
    enum DivideStatus bad = divide_int(12, 0, &value);
    assert(bad == DIVIDE_BY_ZERO && value == 99);
    enum DivideStatus good = divide_int(12, 3, &value);
    assert(good == DIVIDE_OK && value == 4);
    enum DivideStatus no_result = divide_int(1, 1, NULL);
    assert(no_result == DIVIDE_NO_RESULT);
    enum DivideStatus edge = divide_int(INT_MIN, -1, &value);
    assert(edge == (INT_MIN < -INT_MAX ? DIVIDE_RANGE : DIVIDE_OK));
    return 0;
}

Zero quotient valid data hai, isliye ambiguous failure marker nahi hona chahiye. Helper named status return aur sirf success par result write karta hai. Range guard C17 ki permitted signed representations account karta hai: negative range mein extra value ho toh INT_MIN / -1 unrepresentable hai. Null destination aur zero divisor invalid operation se pehle reject hote hain. Failure present kaise karna hai, caller choose karta hai.

3. Errno documented context hai, automatic truth nahi

Complete C17 program
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    const char *text = "12";
    char *end = NULL;
    errno = 0;
    long value = strtol(text, &end, 10);
    int conversion_error = errno;
    if (end == text || *end != '\0' || conversion_error == ERANGE) return EXIT_FAILURE;
    if (printf("value=%ld\n", value) < 0) return EXIT_FAILURE;
    return fflush(stdout) == EOF ? EXIT_FAILURE : EXIT_SUCCESS;
}

<errno.h> ka errno macro C11/C17 mein thread-local storage duration wale modifiable int lvalue designate karta hai. Successful unrelated call old value clear karna required nahi. Strtol jaisi operation ke documented checks require karein toh pehle zero set karein, phir doosri library call se change hone se pehle relevant value capture karein.

ISO C mein har stdio failure par errno set hona required nahi. Isliye arbitrary failure ke baad bare perror("read") stale information describe kar sakta hai, jab tak chosen operation/platform errno contract na de. Perror current errno aur strerror passed error number describe karta hai. Message wording implementation-dependent hai; stable machine protocol ki tarah parse na karein.

4. Assertions expectations check karein, untrusted input nahi

Complete C17 program
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
    if (argc != 2 || strcmp(argv[1], "read") != 0) return EXIT_FAILURE;
    const char *mode = argv[1];
    assert(strcmp(mode, "read") == 0);
    if (printf("mode=%s\n", mode) < 0) return EXIT_FAILURE;
    return fflush(stdout) == EOF ? EXIT_FAILURE : EXIT_SUCCESS;
}

External mode check ordinary control flow hai aur NDEBUG ke saath bhi present rehta hai. Assertion later internal expectation document karti hai. Required read, write, close, assignment ya validation sirf assert mein na rakhein: assertions disable hone par expression completely remove ho sakti hai. Assert failure abnormal termination hai; mistyped filename ka recovery path nahi. Example assertions enabled aur disabled dono mein checked hai.

5. Nonlocal jumps advanced control-flow contract hain

Setjmp/longjmp intervening calls se normally return kiye bina saved environment par control transfer kar sakte hain. Files ya allocations automatically release nahi hote. Saved function invocation same thread mein active rehni chahiye; relevant enclosing variably-modified scope leave karna bhi jump invalidate kar sakta hai. Setjmp function ke changed non-volatile automatic locals longjmp ke baad indeterminate ho sakte hain.

Invocation ke expression contexts bhi restricted hain. if (setjmp(env) == 0) valid hai; int status = setjmp(env); permitted context nahi aur undefined behavior hai. Small test work kare ya nahi, rules independent hain. Is unit ke input flows mein ordinary status returns aur explicit cleanup prefer karein.

Valid saved-jump context dekhein
Complete C17 program
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>

static jmp_buf checkpoint;

static void jump_back(void)
{
    longjmp(checkpoint, 1);
}

int main(void)
{
    if (setjmp(checkpoint) == 0) {
        jump_back();
    } else {
        if (puts("returned to checkpoint") == EOF) return EXIT_FAILURE;
    }
    return fflush(stdout) == EOF ? EXIT_FAILURE : EXIT_SUCCESS;
}

Primary references aur aage ki reading

Aage badhne se pehle

  • Interfaces documented status aur result conventions se failure report karti hain.
  • errno applicable operation ke error rules ke under hi meaningful hai.
  • Assertions assumptions express karti hain; har build ki required validation replace nahi karti.
In ideas ko alag rakhein
Assertion / Input validation
Assertion disable ho sakti hai; untrusted data ki required checks program behavior ka part rehni chahiye.
Apne words mein samjhaayein

Unrelated successful operation ke baad nonzero errno new failure ka enough evidence kyun nahi 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.

Kya sirf nonzero errno se prove hota hai ki last function call fail hui?
Har choice ki explanation padhein
  1. Haan, har successful function errno reset karta hai.

    Successful functions generally errno clear karne ka promise nahi karti.

  2. Haan, errno har function ki return value replace karta hai.

    Har interface apna error indication aur errno kab meaningful hai, define karta hai.

  3. Nahi. Us function ke documented failure indication aur errno rules follow karein.

    ✓ Sahi reasoning. Value kisi earlier operation se bachi ho sakti hai.

C17

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.

C mein exceptions nahi hoti, isliye error handling ordinary return values ke upar banaye gaye conventions par rely karti hai:

  • Return-value conventions. Kai standard functions ek distinctive return value ke through failure signal karte hain — malloc ke liye NULL, kai POSIX calls ke liye -1, getchar ke liye EOF — jisse caller par yeh responsibility aa jaati hai ki woh har call check kare jo fail ho sakti hai.
  • errno. <errno.h> macro define karta hai jo C11/C17 mein thread-local storage wale modifiable int lvalue mein expand hota hai; ordinary global variable hona required nahi. Pehle function ka documented return/error convention check karein: successful call purani errno value clear karna required nahi. strtol jaise functions mein documented checks ke liye call se pehle errno = 0 set karein. perror/strerror error number describe karte hain; har library failure par errno set hona required nahi.
  • assert. <assert.h> ka assert(condition) agar condition false hai toh program ko ek diagnostic message ke saath abort kar deta hai, jo development ke douran programmer errors pakadne ke liye intended hai. <assert.h> include karne se pehle NDEBUG define karna build se saare assertions strip kar deta hai, isliye assert ko kabhi bhi aisi check guard nahi karni chahiye jis par ek release build actually depend karta ho.
  • setjmp/longjmp. longjmp matching setjmp par tabhi laut sakta hai jab woh function invocation abhi active ho aur same thread mein ho; return ho chuke function mein jump karna undefined behavior hai. setjmp wale function ke non-volatile automatic locals, jo setjmp ke baad change hue, longjmp ke baad indeterminate values rakhte hain. Automatic resource cleanup nahi hota. setjmp ke call contexts bhi restricted hain: if (setjmp(env) == 0) valid hai, lekin int status = setjmp(env); undefined behavior hai. Yeh ordinary exceptions nahi.

Agla idea padhne ke liye tayyar?

Mark this chapter as read whenever you feel ready.

CHAPTER 55 / 73

Is chapter mein

Errors, status, errno aur assertions

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