Errors, status, errno aur assertions
Clear failure outcomes design, errno contracts respect, validation assert se bahar aur nonlocal-jump limits recognize karein.
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
| Operation | Interpretation |
|---|---|
| fopen | Non-null stream / null failure |
| fgetc | Character result / EOF; end aur error indicators se distinguish karein |
| fread | Complete elements transferred; short count interpret karein |
| printf | Nonnegative character count / negative failure |
| fseek | Zero success / nonzero failure |
| fclose | Zero success / EOF failure; stream dono cases mein disassociated |
| Custom interface | Documented 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
#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
#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
#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
#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
- WG14 N1570 — public C11 committee draft: 6.5.5p5–p6, 7.2, 7.5, 7.13, 7.21.10, 7.24.6.2. C17 baseline ke stable core provisions ke liye; final ISO publication nahi.
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.
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.
Har choice ki explanation padhein
- Haan, har successful function errno reset karta hai.
Successful functions generally errno clear karne ka promise nahi karti.
- Haan, errno har function ki return value replace karta hai.
Har interface apna error indication aur errno kab meaningful hai, define karta hai.
- 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 —
mallocke liyeNULL, kai POSIX calls ke liye-1,getcharke liyeEOF— 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 modifiableintlvalue mein expand hota hai; ordinary global variable hona required nahi. Pehle function ka documented return/error convention check karein: successful call puranierrnovalue clear karna required nahi.strtoljaise functions mein documented checks ke liye call se pehleerrno = 0set karein.perror/strerrorerror number describe karte hain; har library failure parerrnoset hona required nahi. - assert.
<assert.h>kaassert(condition)agarconditionfalse 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 pehleNDEBUGdefine karna build se saare assertions strip kar deta hai, isliyeassertko kabhi bhi aisi check guard nahi karni chahiye jis par ek release build actually depend karta ho. - setjmp/longjmp.
longjmpmatchingsetjmppar 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.setjmpwale function ke non-volatile automatic locals, josetjmpke baad change hue,longjmpke baad indeterminate values rakhte hain. Automatic resource cleanup nahi hota.setjmpke call contexts bhi restricted hain:if (setjmp(env) == 0)valid hai, lekinint 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.