struct, union আর enum — বাস্তব জিনিসকে ডেটায় সাজানো

১ · একটি জিনিস, অনেকগুলো তথ্য — ডেটা মডেলিং

আপনার কলেজের একজন ছাত্রের কথা ভাবুন। তার একটি নাম আছে, একটি রোল নম্বর আছে, একটি GPA আছে। এই তিনটি তথ্য আলাদা আলাদা টাইপের — নাম হলো লেখা (char-এর array), রোল পূর্ণসংখ্যা (int), আর GPA দশমিক সংখ্যা (double). কিন্তু তিনটি মিলে একজন মানুষ।

এ পর্যন্ত আমাদের হাতে ছিল শুধু আলাদা আলাদা ভ্যারিয়েবল আর একই টাইপের array. তাই ৬০ জন ছাত্রের তথ্য রাখতে গেলে বানাতে হতো তিনটি আলাদা array:

char   names[60][20];
int    rolls[60];
double gpas[60];      /* rolls[7] আর gpas[7] একই ছাত্রের — শুধু আমরা জানি */

এটা কাজ করে, কিন্তু খুব ভঙ্গুর। কেউ যদি শুধু rolls sort করে আর gpas ভুলে যায়, তাহলে রাফির GPA চলে যাবে নুসরাতের নামে। কোনো error আসবে না — শুধু ফলাফল ভুল হবে। সমস্যার মূল হলো, “এই তিনটি তথ্য একসাথে একজন ছাত্র” — এই সম্পর্কটি কোডের কোথাও লেখা নেই। সম্পর্কটি আছে শুধু প্রোগ্রামারের মাথায়।

বাস্তবের কোনো জিনিসকে প্রোগ্রামে আনার আগে নিজেকে তিনটি প্রশ্ন করুন: এর কোন কোন তথ্য আমার কাজে লাগবে? প্রতিটি তথ্য কোন টাইপে রাখব? কোন তথ্যগুলো একসাথে বদলায় বা একসাথে চলাফেরা করে? এই চিন্তাকেই বলে data modelling. কয়েকটি উদাহরণ দেখুন:

২ · struct, typedef আর নাম ধরে শুরুর মান

struct দিয়ে আপনি C-কে বলেন: “এই কয়েকটি তথ্য মিলে একটি নতুন টাইপ হলো।” ভেতরের প্রতিটি তথ্যকে বলে member (বা field). প্রথমে লেখার সবচেয়ে সরল রূপ:

struct Student {
    char   name[20];
    int    roll;
    double gpa;
};                       /* শেষের সেমিকোলন ভুলবেন না */

struct Student a;        /* টাইপের নাম দুই শব্দের: struct Student */

খেয়াল করুন, এই অংশটি শুধু একটি নকশা। এটি লেখার সময় কোনো মেমরি নেওয়া হয় না — যেমন প্রবেশপত্রের ফাঁকা ফর্ম ছাপালে কোনো ছাত্রের তথ্য তৈরি হয় না। মেমরি নেওয়া হয় তখনই, যখন struct Student a; লিখে একটি আসল ভ্যারিয়েবল বানান।

typedef — টাইপকে ছোট একটি নাম দেওয়া

প্রতিবার struct Student লেখা একটু ঝামেলার। typedef একটি পুরোনো টাইপকে নতুন নাম দেয়। সাধারণত struct-এর সাথে একসাথেই লেখা হয়:

typedef struct {
    char   name[20];
    int    roll;
    double gpa;
} Student;               /* এখন থেকে শুধু Student লিখলেই চলবে */

Student a;

typedef নতুন কোনো টাইপ তৈরি করে না, শুধু একটি ডাকনাম দেয়। size_t, uint32_t — এগুলোও আসলে standard library-র typedef. একটি নিয়ম মনে রাখুন: নাম যেন কাজ বোঝায়। Student, Transaction, Ticket ভালো নাম; S1, MyType খারাপ।

Designated initializer — নাম ধরে মান বসানো

struct ভ্যারিয়েবল বানানোর সাথেই মান দিতে পারেন। পুরোনো পদ্ধতিতে মানগুলো ক্রম অনুযায়ী লিখতে হয়: {"Rafi", 17, 3.40}. কিন্তু ক্রম ভুল হলে? কেউ যদি পরে struct-এ নতুন একটি member মাঝখানে ঢোকায়? C99 থেকে এর একটি ভালো সমাধান আছে — designated initializer, অর্থাৎ member-এর নাম ধরে মান বসানো:

Student a = { .name = "Rafi", .roll = 17, .gpa = 3.40 };
Student b = { .roll = 18 };    /* name হবে "" আর gpa হবে 0.0 */

একটি struct আরেকটিতে সরাসরি কপি করা যায়: b = a; লিখলে a-এর সব বাইট b-তে চলে যায়। কিন্তু a == b দিয়ে দুটি struct তুলনা করা যায় না — compiler error দেবে। তুলনা করতে হয় member ধরে ধরে। কেন বাইট ধরে তুলনা করাও বিপজ্জনক, সেটা অংশ ৫-এ padding দেখার পর পরিষ্কার হবে।

৩ · ডট আর তীর — member পড়া, struct-এর array, struct-এর ভেতরে struct

struct-এর ভেতরের একটি member পড়তে বা বদলাতে লাগে dot operator: a.roll = 20; বা printf("%s", a.name);. বাক্যটি এভাবে পড়ুন — “a-এর roll”.

কিন্তু পর্ব ১৭ আর ১৮-তে দেখেছেন, বড় জিনিস নিয়ে কাজ করতে আমরা প্রায়ই তার ঠিকানা (pointer) হাতে রাখি। ধরুন Student *p = &a;. এখন p দিয়ে roll পড়তে চাইলে আগে ঠিকানা থেকে struct-টি বের করতে হবে, তারপর তার roll: (*p).roll. বন্ধনী বাদ দিলে ভুল হয়, কারণ .-এর precedence *-এর চেয়ে বেশি। এত বন্ধনী ঝামেলার, তাই C একটি ছোট চিহ্ন দিয়েছে — arrow operator:

struct-এর array — পুরো ক্লাসের তালিকা

এখন সেই ৬০ জনের তালিকা আর তিনটি আলাদা array-তে নয়, একটিতেই: Student cls[60];. প্রতিটি ঘরে একজন পূর্ণ ছাত্র। cls[7].gpa মানে “তালিকার ৭ নম্বর ঘরের ছাত্রের GPA”. এখন sort করলে পুরো struct একসাথে সরে — নাম আর GPA আর কখনো আলাদা হয় না।

নিচের debugger সিমুলেটরে তিনজন ছাত্রের তালিকা থেকে সর্বোচ্চ GPA খোঁজা হচ্ছে। লক্ষ করুন, আমরা পুরো struct কপি করে রাখছি না — শুধু সেরা ছাত্রের ঘর নম্বর (best) মনে রাখছি। “পরে” চাপুন:

1Student cls[3] = {2  {"Rafi",   1, 3.40},3  {"Nusrat", 2, 3.85},4  {"Tanvir", 3, 3.60} };5int best = 0;6for (int i = 1; i < 3; i++) {7    if (cls[i].gpa > cls[best].gpa)8        best = i;9}10printf("Top: %s (%.2f)\n",11       cls[best].name, cls[best].gpa);

struct-এর ভেতরে struct

ছাত্রের ঠিকানাও তো কয়েকটি অংশে ভাগ করা — এলাকা, জেলা, পোস্ট কোড। ঠিকানার জন্য আলাদা একটি struct বানিয়ে সেটি ছাত্রের ভেতরে রাখা যায়। একে বলে nested struct:

typedef struct { char area[24]; char district[16]; int post_code; } Address;
typedef struct { char name[20]; int roll; double gpa; Address home; } Student;

Student s = { .name = "Rafi", .roll = 17, .home = { .district = "Rajshahi", .post_code = 6000 } };
printf("%s\n", s.home.district);      /* ডট দুবার: s-এর home-এর district */

এতে দুটি লাভ। এক, ঠিকানার নকশা একবার লিখে ছাত্র, শিক্ষক, দোকান — সবার ভেতরে ব্যবহার করা যায়। দুই, কোড পড়তে বাস্তবের মতো লাগে। ছোট ছোট অর্থপূর্ণ টুকরো জুড়ে বড় জিনিস বানানো — এটাই abstraction-এর প্রথম ধাপ।

এবার সব একসাথে চালিয়ে দেখুন — typedef, designated initializer, struct-এর array আর const ঠিকানা দিয়ে ফাংশনে পাঠানো:

#include <stdio.h>

typedef struct { char name[20]; int roll; double gpa; } Student;

void print_student(const Student *s) {
    printf("%-8s roll %2d  GPA %.2f\n", s->name, s->roll, s->gpa);
}

int main(void) {
    Student cls[] = {
        { .name = "Rafi",   .roll = 1, .gpa = 3.40 },
        { .name = "Nusrat", .roll = 2, .gpa = 3.85 },
        { .name = "Tanvir", .roll = 3, .gpa = 3.60 },
    };
    int n = sizeof cls / sizeof cls[0];
    for (int i = 0; i < n; i++) print_student(&cls[i]);
    printf("sizeof(Student) = %zu bytes\n", sizeof(Student));
    return 0;
}

৪ · ফাংশনে struct পাঠানো — পুরো কপি, নাকি শুধু ঠিকানা

পর্ব ১৩-এ দেখেছেন, C-তে ফাংশনে মান পাঠানো হয় pass by value পদ্ধতিতে — ফাংশন পায় একটি কপি। struct-এর বেলাতেও তাই। void show(Student s) ডাকলে পুরো struct-এর সব বাইট নতুন করে কপি হয়ে ফাংশনের stack frame-এ বসে।

কপির খরচ ছোট struct-এ চোখে পড়ে না। কিন্তু ধরুন একটি struct-এর ভেতরে ৪০৯৬ বাইটের একটি buffer আছে, আর একটি লুপ ফাংশনটিকে দশ লাখবার ডাকছে — প্রতিবার ৪ KB কপি। তার ওপর, stack-এর জায়গা সীমিত; খুব বড় struct by value পাঠালে বা recursion-এর ভেতরে পাঠালে stack overflow-এর ঝুঁকিও বাড়ে।

৫ · মেমরিতে struct — alignment আর padding

এবার একটি ধাঁধা। নিচের struct-এ আছে একটি char (১ বাইট), একটি double (৮ বাইট) আর একটি int (৪ বাইট)। যোগ করলে ১৩ বাইট। কিন্তু সাধারণত ৬৪-বিট Linux-এ sizeof বলবে ২৪! বাকি ১১ বাইট কোথায় গেল?

struct Bad { char c; double d; int i; };   /* member-এর যোগফল 13, sizeof সাধারণত 24 */

কেন alignment লাগে

CPU মেমরি থেকে এক বাইট এক বাইট করে পড়ে না। সে পড়ে বড় বড় টুকরোয় — একসাথে ৪ বা ৮ বাইট, আর cache-এ আনে আরও বড় একটি টুকরো (cache line, সাধারণত ৬৪ বাইট)। এই টুকরোগুলো শুরু হয় নির্দিষ্ট সীমানা থেকে — ০, ৮, ১৬, ২৪… ঠিকানায়।

একটি ৮ বাইটের double যদি ৮-এর গুণিতক ঠিকানায় শুরু হয়, তাহলে পুরোটা একটি টুকরোর ভেতরে পড়ে — CPU এক চেষ্টায় পড়ে ফেলে। কিন্তু যদি ঠিকানা ১ থেকে শুরু হয়, তাহলে মানটি দুটি টুকরোয় ভাগ হয়ে যায় — CPU-কে দুবার পড়ে জোড়া লাগাতে হয়। আধুনিক Intel/AMD CPU এটা পারে, শুধু কখনো কখনো ধীর হয়। কিন্তু কিছু CPU (যেমন SPARC, আর অনেক ছোট microcontroller) এমন বেঠিক ঠিকানা থেকে পড়তে গেলে সরাসরি error দেয় — প্রোগ্রাম crash করে।

নিয়মটি সাধারণত এরকম: char যেকোনো ঠিকানায় বসতে পারে, int বসে ৪-এর গুণিতকে, double বসে ৮-এর গুণিতকে। Compiler struct-এর member-দের যে ক্রমে লিখেছেন সেই ক্রমেই বসায় (C-র নিয়ম, ক্রম বদলানোর অনুমতি নেই), আর দরকার হলে মাঝে ফাঁকা বাইট ঢোকায়। নিচে ধাপে ধাপে দেখুন — প্রতিটি সারি ৮ বাইট, · মানে padding:

struct Bad {
    char   c;   /* 1 বাইট, যেকোনো ঠিকানায় */
    double d;   /* 8 বাইট, 8-এর গুণিতকে */
    int    i;   /* 4 বাইট, 4-এর গুণিতকে */
};

offset   0  1  2  3  4  5  6  7
 0-7   [c][ ][ ][ ][ ][ ][ ][ ]

offset   0  1  2  3  4  5  6  7
 0-7   [c][·][·][·][·][·][·][·]   ← padding
 8-15  [d][d][d][d][d][d][d][d]

offset   0  1  2  3  4  5  6  7
 0-7   [c][·][·][·][·][·][·][·]
 8-15  [d][d][d][d][d][d][d][d]
16-23  [i][i][i][i][ ][ ][ ][ ]

offset   0  1  2  3  4  5  6  7
 0-7   [c][·][·][·][·][·][·][·]
 8-15  [d][d][d][d][d][d][d][d]
16-23  [i][i][i][i][·][·][·][·]   ← শেষের padding

array-র পরের struct শুরু হবে 24-এ — 8-এর গুণিতক

offset   0  1  2  3  4  5  6  7
 0-7   [d][d][d][d][d][d][d][d]
 8-15  [i][i][i][i][c][·][·][·]

sizeof = 16   একই তথ্য, 8 বাইট কম

নিজে মেপে দেখুন। stddef.h-এর offsetof বলে দেয় কোনো member struct-এর শুরু থেকে কত বাইট দূরে বসেছে:

#include <stdio.h>
#include <stddef.h>

struct Bad  { char c; double d; int i; };
struct Good { double d; int i; char c; };

int main(void) {
    printf("Bad : size %zu | c@%zu d@%zu i@%zu\n", sizeof(struct Bad),
           offsetof(struct Bad, c), offsetof(struct Bad, d),
           offsetof(struct Bad, i));
    printf("Good: size %zu | d@%zu i@%zu c@%zu\n", sizeof(struct Good),
           offsetof(struct Good, d), offsetof(struct Good, i),
           offsetof(struct Good, c));
    printf("sum of members = %zu\n",
           sizeof(char) + sizeof(double) + sizeof(int));
    return 0;
}

GCC আর Clang-এ __attribute__((packed)) লিখে padding পুরোপুরি বন্ধ করা যায় — একে বলে packed struct. তখন struct Bad-এর মাপ হবে ১৩. কিন্তু তখন d আর i বেঠিক ঠিকানায় বসবে — পড়া ধীর হতে পারে, কিছু CPU-তে crash-ও করতে পারে। এটি C standard-এর অংশ নয়; কখন ব্যবহার করা ঠিক, তা ভাবনার প্রশ্ন ১-এ আলোচনা করা হয়েছে।

৬ · enum — জাদুর সংখ্যার বদলে নাম

লেনদেনের struct-এ একটি তথ্য বাকি — ধরন: Send Money, Cash Out, না Mobile Recharge. অনেকে (এবং অনেক AI) এটা লেখেন এভাবে:

if (tx.type == 2) { ... }     /* 2 মানে কী? Cash Out? Recharge? */

এই 2-কে বলে magic number — কোডের মাঝে বসানো একটি সংখ্যা, যার অর্থ শুধু লেখক জানেন (এবং ছয় মাস পরে তিনিও ভুলে যান)। কেউ ভুল করে tx.type = 7 লিখলেও কেউ আটকাবে না। সমাধান হলো enum — সম্ভাব্য পছন্দগুলোকে নাম দিয়ে একটি টাইপ বানানো:

typedef enum { TX_SEND, TX_CASHOUT, TX_RECHARGE } TxType;   /* 0, 1, 2 */

typedef struct {
    char      id[11];          /* TrxID */
    long long amount_poisha;   /* 500 taka = 50000 */
    time_t    when;
    TxType    type;
} Transaction;

if (tx.type == TX_CASHOUT) { ... }   /* পড়লেই বোঝা যায় */

ভেতরে enum-এর প্রতিটি নাম আসলে একটি int ধ্রুবক — প্রথমটি ০, তারপর ১, ২… চাইলে নিজে মান দিতে পারেন: enum { LOW = 1, MID = 5, HIGH = 10 };. তাহলে লাভ কী? তিনটি:

• পড়া সহজ: TX_CASHOUT নিজেই নিজের অর্থ বলে।
• এক জায়গায় তালিকা: নতুন ধরন (যেমন TX_PAYBILL) যোগ করতে একটি লাইন বদলালেই হয়।
• Compiler সাহায্য করে: enum-এর ওপর switch লিখে কোনো একটি নাম বাদ দিলে, আর default না রাখলে, -Wall চালু থাকলে GCC সতর্ক করে: enumeration value 'TX_RECHARGE' not handled in switch. নতুন ধরন যোগ করার পর কোথায় কোথায় কোড বদলাতে হবে, compiler নিজেই দেখিয়ে দেয়।

৭ · union — এক জায়গা, অনেক রূপ

struct-এ প্রতিটি member-এর নিজের জায়গা থাকে, পাশাপাশি। union দেখতে প্রায় একই রকম, কিন্তু একটি বড় পার্থক্য: সব member একই ঠিকানা থেকে শুরু হয়, একই বাইট ভাগ করে নেয়। তাই union-এর মাপ হয় তার সবচেয়ে বড় member-এর মাপ (alignment-এর জন্য দরকার হলে একটু বেশি)। একটিতে লিখলে বাকিগুলোর মান মুছে যায় বা বদলে যায়।

নিচের ডায়াগ্রামে একটি ৪ বাইটের union-এ প্রথমে একটি পূর্ণসংখ্যা, পরে একটি float লেখা হচ্ছে, আর একই বাইটগুলো ভিন্ন ভিন্ন member দিয়ে পড়া হচ্ছে। পর্ব ০৫-এর endianness মনে রাখুন — x86 আর বেশিরভাগ ARM সিস্টেম little-endian, অর্থাৎ সংখ্যার ছোট দিকের বাইট আগে বসে।

1union Num {2    unsigned int  i;3    float         f;4    unsigned char b[4];5};6union Num u;7u.i = 65;8printf("%c\n", u.b[0]);9u.f = 1.0f;10printf("%u\n", u.i);

Tagged union — “কয়েক রকমের মধ্যে একটি”

union-এর আসল কাজ হলো এমন ডেটা রাখা, যা একসময় কয়েক রকমের যেকোনো একটি। একটি চ্যাট অ্যাপের মেসেজ ভাবুন: সেটি হয় লেখা, নয় ছবি, নয় টাকা পাঠানো। তিনটির জন্য তিনটি আলাদা জায়গা রাখা অপচয়, কারণ একটি মেসেজ একসাথে তিনটি হয় না। কিন্তু শুধু union রাখলে প্রশ্ন ওঠে — এখন বোর্ডে কোন বিষয় লেখা আছে? union নিজে তা মনে রাখে না।

সমাধান: একটি enum ট্যাগ আর union একসাথে একটি struct-এ রাখা। ট্যাগ বলে দেয় কোন member এখন বৈধ। একে বলে tagged union:

typedef enum { MSG_TEXT, MSG_IMAGE, MSG_PAYMENT } MsgKind;

typedef struct {
    MsgKind kind;                                   /* ট্যাগ: এখন কোনটি বৈধ */
    union {
        char text[64];                              /* kind == MSG_TEXT    */
        struct { int width, height; } image;        /* kind == MSG_IMAGE   */
        struct { long long poisha; char to[12]; } pay;   /* MSG_PAYMENT    */
    } as;
} Message;

এখন যেকোনো মেসেজ হাতে পেলে আগে ট্যাগ দেখুন, তারপর শুধু সেই member পড়ুন। নিচের ডায়াগ্রামে তিনটি মেসেজ একটি switch-এর ভেতর দিয়ে যাচ্ছে:

[ kind ][ ----------- as (64 বাইট) ----------- ]
           text  : 64 বাইটের লেখা
           image : width, height  (একই জায়গার শুরুতে)
           pay   : poisha, to     (একই জায়গার শুরুতে)

case MSG_TEXT:
    printf("Text: %s\n", m.as.text);
    break;
Text: Kal class 9tay

case MSG_PAYMENT:
    printf("Sent %lld.%02lld Tk to %s\n",
           m.as.pay.poisha / 100, m.as.pay.poisha % 100, m.as.pay.to);
    break;
Sent 500.00 Tk to 017XXXXXXXX

/* কেউ ট্যাগ না দেখেই লিখল: */
printf("%s\n", m.as.text);
����@  ← width/height-এর বাইটকে লেখা ভেবে পড়া

compiler কিছুই বলে না — টাইপ তো ঠিকই আছে

৮ · Bit field — বিট গুনে জায়গা দেওয়া

পর্ব ০৯-এ দেখেছেন, bit flag দিয়ে একটি সংখ্যার ভেতরে অনেকগুলো হ্যাঁ/না রাখা যায়, আর bit mask দিয়ে নির্দিষ্ট বিট চালু, বন্ধ বা পরীক্ষা করা যায়। struct-এর ভেতরে একই কাজ আরেকভাবে করা যায় — member-এর মাপ বিট গুনে বলে দিয়ে:

struct AccountFlags {
    unsigned int verified : 1;   /* 0 বা 1 */
    unsigned int blocked  : 1;   /* 0 বা 1 */
    unsigned int level    : 3;   /* 0 থেকে 7 */
};

struct AccountFlags f = { .verified = 1, .level = 5 };
if (f.verified && !f.blocked) { ... }    /* মাস্ক লিখতে হলো না */

এগুলোকে বলে bit field. পাঁচটি বিটের তথ্য, অথচ কোড পড়তে সাধারণ member-এর মতো — f.blocked = 1. compiler নিজেই পেছনে &, |, শিফট লিখে দেয়। level-এ ৩ বিট মানে সর্বোচ্চ ৭; ৯ বসাতে চাইলে মানটি কেটে যায় (ওপরের বিট হারায়), আর GCC সাধারণত একটি সতর্কবার্তা দেয়।

কোথায় কাজে লাগে

• হার্ডওয়্যার register: একটি microcontroller-এর ৩২ বিটের control register-এ হয়তো ৩ বিট গতি, ১ বিট চালু/বন্ধ, ৪ বিট মোড। bit field দিয়ে লিখলে কোড ডেটাশিটের ছকের মতো দেখায়।
• নেটওয়ার্ক প্রোটোকলের header: IPv4 header-এর প্রথম বাইটে ৪ বিট version আর ৪ বিট header-এর দৈর্ঘ্য। Linux kernel-এর struct iphdr এগুলো bit field দিয়েই লেখে।
• লক্ষ লক্ষ ছোট রেকর্ড: প্রতিটিতে কয়েকটি হ্যাঁ/না থাকলে, আলাদা int-এর বদলে কয়েকটি বিট — মোট মেমরি অনেক কমে।

সব টুকরো একসাথে

৯ · AI-এর যুগে — struct কোডে AI যেসব ভুল করে

AI-কে “একটি ছাত্র ব্যবস্থাপনা প্রোগ্রাম লেখো” বললে সেকেন্ডেই struct-ভরা কোড পাবেন। দেখতে পরিষ্কার, চলেও। কিন্তু ভুলগুলো থাকে নকশায় — যেগুলো compiler ধরে না, শুধু বোঝেন এমন একজন মানুষ ধরেন। পরের পর্বের প্রজেক্টে আপনি নিজেই struct দিয়ে একটি টুল বানাবেন, তাই এই তালিকা এখনই কাজে লাগবে।

AI-এর struct কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• কোনো == 2 বা = 3-এর মতো ব্যাখ্যাহীন সংখ্যা নেই — প্রতিটি পছন্দের জন্য enum-এর নাম আছে
• বড় struct ফাংশনে যাচ্ছে const ঠিকানা দিয়ে; যেখানে by value, সেখানে struct সত্যিই ছোট
• প্রতিটি union-এর সাথে একটি ট্যাগ আছে, আর প্রতিটি পড়ার আগে ট্যাগ যাচাই হচ্ছে
• মেমরির মাপ সবসময় sizeof দিয়ে, কোথাও হাতে লেখা সংখ্যা নেই
• struct সরাসরি fwrite/send হচ্ছে না, অথবা হলে কারণ আর সীমাবদ্ধতা লেখা আছে
• struct তুলনা হচ্ছে member ধরে, memcmp দিয়ে নয়