YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Data ka designChapter 37 of 73

Types, declarations aur data interfaces

Aliases aur qualifiers precisely padhein, invariants validate karein aur explicit lifetime contracts ke saath opaque interfaces samjhein.

6 min readCore conceptsC17 baseline
Offline reading
Is chapter mein8 sections
0% through this chapter

Declaration types aur names batati hai. Useful data interface ko valid states, allowed changes aur storage ki responsibility bhi batani chahiye. Declarations carefully padhkar woh promises add karenge jo syntax akela express nahi kar sakta.

1. typedef type ko doosra naam deta hai

C17 · illustrative fragment
struct Point { int x; int y; };
typedef struct Point Point;
Point location = {2, 3};
struct Point copy = location;

typedef existing type ka alias introduce karta hai, distinct incompatible type ya object nahi. Yahan Point aur struct Point same type name karte hain. Separately declared struct Pixel { int x; int y; }; alag structure type describe karta hai, though members similar dikhte hain. Type identity aur similar representation different facts hain.

Alias long declaration readable bana sakta hai, lekin pointer hide bhi kar sakta hai. Qualifiers attach ya ownership infer karne se pehle aliased type samjhein. Buffer jaisa naam khud nahi batata copy karne se storage duplicate hoti hai, view borrow hota hai ya responsibility transfer hoti hai.

2. Qualifiers actual named type par apply hote hain

C17 · illustrative fragment
typedef int *IntPointer;
int value = 4;
const IntPointer fixed = &value;
*fixed = 7;

IntPointer ka meaning already pointer to int hai. const add karne se pointer object initialization ke baad nonmodifiable hota hai; pointed-to integer mein const add nahi hota. *fixed se integer change ho sakta hai. Yeh const int *view se alag hai, jo us view se integer change karna restrict karta hai.

C17 · illustrative fragment
struct View { int *items; size_t count; };
int numbers[2] = {1, 2};
const struct View view = {numbers, 2};
view.items[0] = 9;

Isi tarah int * member wali const structure target integers ko recursively const nahi banati. Const structure se member ka pointer value reassign nahi ho sakta, lekin woh target access ke liye int * value deta hai. Appropriate pointed-to types se read-only views design karein aur modifiable storage document karein. Fragment ke size_t ke liye <stddef.h> include karein.

3. Clear boundary par relationships validate karein

Invariant woh relationship hai jo operations preserve karna chahte hain. Yahan lower <= upper hai. Constructor-style function relationship establish karne ke liye chosen ordinary C function hai, automatic language constructor nahi. Contract ko failure par output ka behavior batana chahiye.

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

struct Range { int lower; int upper; };

static bool make_range(int lower, int upper, struct Range *result)
{
    if (result == NULL || lower > upper) return false;
    *result = (struct Range){.lower = lower, .upper = upper};
    return true;
}

int main(void)
{
    struct Range range = {0, 0};
    assert(!make_range(5, 1, &range));
    assert(range.lower == 0 && range.upper == 0);
    assert(make_range(1, 5, &range));
    assert(range.lower <= range.upper);
    assert(!make_range(1, 5, NULL));
    return 0;
}

Saare checks assignment se pehle hain, isliye invalid inputs existing output unchanged rakhte hain. Null output pointer use se pehle reject hota hai. Public structure ab bhi other code ko directly inconsistent members write karne deti hai; function akela prevent nahi kar sakta. Har update controlled operations se karwana ho toh representation incomplete type ke peeche hide karein.

  1. Inputs lein
  2. Relationships check
  3. Valid state commit
  4. Result report
Is function ka validation pattern, automatic transaction ya synchronization guarantee nahi.

4. Incomplete type opaque interface define kar sakta hai

C17 · translation-unit fragment
struct Sensor;
typedef struct Sensor Sensor;

Sensor *sensor_create(int initial_value);
int sensor_read(const Sensor *sensor);
void sensor_destroy(Sensor *sensor);

Yeh interface declarations hain, complete program nahi. Definitions doosri jagah supply honi chahiye. Caller structure members dekhe bina Sensor * hold kar sakta hai, jabki ordinary sizeof(Sensor) ya value se complete Sensor object create karne ke liye completed type chahiye. Yeh opaque-type interface hai, jo headers aur multiple source files ke saath further develop hoga.

Declarations abhi yeh promise nahi karti ki create fail ho sakta hai, read null accept karta hai ya destroy do baar call ho sakta hai. Rules explicitly state karein. Function ownership return kare toh matching release operation specify karein. Borrowed pointer return kare toh invalidating operation specify karein. Const access akela ownership ya thread safety communicate nahi karta.

5. Interface guess karne se pehle declarator padhein

int *items[3] pointers ki array declare karta hai; int (*items)[3] array ka pointer. int (*operation)(int, int) function pointer declare karta hai, jabki int *operation(int, int) pointer return karne wala function. Parentheses aur declarator structure type decide karte hain. Function-pointer typedef readability mein help kar sakta hai, lekin calls ko compatible function type aur valid argument contract ab bhi chahiye.

Useful interface description five questions saath answer karti hai: valid input kya hai, result kya hai, kya change ho sakta hai, referenced lifetimes kaun manage karega aur failure kaise report hogi. Isse declarations stars aur brackets ka puzzle hone ke bajay useful documentation banti hain.

Primary references aur aage padhne ke liye

Declarator ko concrete behavior choice se jodne ke liye Function pointers aur callbacks padhein.

Aage badhne se pehle

  • Typedef type ko doosra naam deta hai aur pointer details hide kar sakta hai.
  • Qualifiers actual aliased type par apply hote hain; declarator structure important hai.
  • Useful interfaces valid states, mutation, ownership, lifetime aur failure behavior batate hain.
In ideas ko alag rakhein
Opaque type / Automatic validation
Representation hide karne se access paths control ho sakte hain; public operations ko valid contracts aur implementations phir bhi chahiye.
Apne words mein samjhaayein

Pointer typedef ki wajah se const declaration ka expected meaning kaise badal sakta 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.

int *a, b; mein kaunsa declarator pointer declare karta hai?
Har choice ki explanation padhein
  1. a aur b dono.

    Star, a ke declarator ka part hai; declaration ke har naam par automatically apply nahi hota.

  2. Sirf b.

    Star, a ke declarator se attached hai.

  3. Sirf a; b ka type int hai.

    ✓ Sahi reasoning. Shared type specifier ke saath har declarator separately padhein.

C17

Earlier edition ka quick reference

Existing section links aur saved passages ke liye retained. Connected explanations ke liye expanded lessons follow karein.

Kuch C constructs experienced programmers ko bhi confuse karne ke liye notorious hain, isliye nahi ki underlying rule complicated hai, balki isliye kyunki syntax ko misread karna aasan hai.

Array of Pointers vs. Pointer to an Array

int *arr[10] aur int (*arr)[10] dekhne mein almost identical lagte hain lekin bahut different cheezein declare karte hain:

  • int *arr[10]; — 10 elements ka ek array, jinme se har ek int ka ek pointer hai.
  • int (*arr)[10]; — 10 ints ke ek array ka ek single pointer.

Rule of thumb yeh hai ki [], * se zyada tightly bind karta hai jab tak parentheses kuch aur na kahen, isliye "andar se bahar" (inside out) padhna — jahan arr sabse pehle apne sabse nazdeeki operator ke saath group hota hai, parentheses ko respect karte hue — yeh ambiguity har baar resolve kar deta hai.

Structures Ko == Se Compare Nahi Kiya Ja Sakta

C structure operands ke liye == define nahi karti; aisa expression constraint violate karta hai aur diagnostic required hai. Relevant members compare karein, jaise p1.x == p2.x && p1.y == p2.y && p1.z == p2.z. memcmp object representations compare karta hai, semantic equality nahi: padding bytes alag ho sakti hain aur equal member values ki representations bhi alag ho sakti hain. = {0} initializer generally fixed padding guarantee nahi karta; poori storage zero karne ke baad member stores padding badal sakte hain. General member-wise comparison ke replacement mein memcmp use na karein.

Complex Declarations Padhna

int (*fp)(int, int); jaisi ek declaration "fp do ints lene wale aur int return karne wale function ka ek pointer hai" ke roop mein padhi jaati hai — *fp ke around parentheses essential hain, kyunki int *fp(int, int) iske bajaye ek function declare karta hai jo int * return karta hai. Ek typedef usually isse kahin zyada readable bana deta hai:

C17 · illustrative fragment
int add(int a, int b);  /* linking ke liye definition deni hogi */
typedef int (*BinOp)(int, int);
BinOp fp = add;

Agla idea padhne ke liye tayyar?

Mark this chapter as read whenever you feel ready.

CHAPTER 37 / 73

Is chapter mein

Types, declarations aur data interfaces

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