স্কোপ ও স্টোরেজ ক্লাস — কোথায় দেখা যায়, কতক্ষণ বাঁচে

১ · দুটি আলাদা প্রশ্ন — কোথায় দেখা যায়, কতক্ষণ বাঁচে

পর্ব ১৩-এ ফাংশন শেখার সময় scope আর lifetime-এর সাথে প্রথম পরিচয় হয়েছে। এই পর্বে বিষয়টি পুরোপুরি খুলে দেখব, কারণ বড় প্রোগ্রামের অনেক রহস্যময় বাগের মূলে এই দুটি ধারণা। শুরু করি একটি সাধারণ উদাহরণ দিয়ে।

C-তে প্রতিটি ভ্যারিয়েবলের জন্য তিনটি প্রশ্ন করা যায়, আর তিনটির উত্তর আলাদা হতে পারে:

যেকোনো ঘোষণা দেখলে এই তিনটি প্রশ্ন নিজেকে করার অভ্যাস করুন। ভ্যারিয়েবলটি কোথায় লেখা (ফাংশনের ভেতরে না বাইরে) আর তার সামনে কোন শব্দ আছে (static, extern বা কিছু না) — এই দুটি দেখলেই তিনটি উত্তর পাওয়া যায়। এই শব্দগুলোকে একসাথে বলে storage class specifier.

২ · Scope-এর এলাকা — block, ফাইল আর আরও দুটি

C-এর নিয়মে scope চার রকম। প্রতিদিন কাজে লাগে প্রথম দুটি; বাকি দুটি জানা থাকলে পরীক্ষায় আর কোড পড়তে সুবিধা হয়।

শেষ দুটি নিয়ে দুই লাইন। Label-এর scope পুরো ফাংশন, তাই goto cleanup; লিখে নিচের দিকে লাফ দেওয়া যায়, যদিও label-টি তখনো লেখা হয়নি (পর্ব ৩০-এ এর ভালো ব্যবহার দেখবেন)। আর prototype-এর parameter নাম শুধু পড়ার সুবিধার জন্য — int area(int, int); লিখলেও চলে, নামগুলো বন্ধনী শেষ হতেই হারিয়ে যায়।

Shadowing — ভেতরের নাম বাইরেরটিকে ঢেকে দেয়

একই নাম দুই স্তরে ঘোষণা করলে compiler কোনো error দেয় না। নিয়ম একটাই: নাম খোঁজা হয় ভেতর থেকে বাইরের দিকে, প্রথম যেটি পাওয়া যায় সেটিই। ভেতরের নামটি বাইরেরটিকে ঢেকে দেয় — একে বলে shadowing. পর্ব ১৩-এ একটি সহজ উদাহরণ দেখেছেন। এবার একটু কঠিন একটি: এখানে global, parameter, ভেতরের block আর লুপ — চার জায়গায় x. প্রতিটি printf কোন x দেখছে, আগে নিজে অনুমান করুন, তারপর “পরে” চাপুন।

1#include <stdio.h>23int x = 10;                  // file scope45void show(int x) {           // parameter6    printf("A %d\n", x);7    {8        int x = 30;          // block9        printf("B %d\n", x);10    }11    printf("C %d\n", x);12}1314int main(void) {15    show(20);16    for (int x = 0; x < 1; x++)17        printf("D %d\n", x);18    printf("E %d\n", x);19    return 0;20}

৩ · Storage duration — চার রকম আয়ু

এবার দ্বিতীয় প্রশ্ন: বাক্সটি কতক্ষণ বাঁচে। C-এর নিয়মে আয়ু চার রকম।

সাধারণ local ভ্যারিয়েবলকে বলে automatic variable, কারণ এর জন্ম-মৃত্যু নিজে থেকেই হয়। পর্ব ১৩-এর call stack মনে করুন: ফাংশন ডাকলে একটি stack frame তৈরি হয়, local ভ্যারিয়েবলগুলো থাকে সেই frame-এর ভেতরে, আর ফাংশন ফিরলে পুরো frame একসাথে মুছে যায়। অন্যদিকে static variable stack-এ থাকেই না — থাকে প্রোগ্রামের স্থায়ী এলাকায়। নিচের ডায়াগ্রামে দুটিকে পাশাপাশি দেখুন, বিশেষ করে বাঁ দিকের “Stack” সারিটি:

1#include <stdio.h>23void serve(void) {4    int x = 0;            // automatic5    static int count;     // static, শুরুতে 06    x++;7    count++;8    printf("x=%d count=%d\n", x, count);9}1011int main(void) {12    serve();13    serve();14    serve();15    return 0;16}

শুরুর মান — static পায় শূন্য, automatic পায় আবর্জনা

পর্ব ০৬-এ দেখেছেন, মান না দেওয়া local ভ্যারিয়েবলের ভেতরে থাকে garbage value — stack-এর ওই জায়গায় আগে যা ছিল তাই। কিন্তু static আয়ুর ভ্যারিয়েবলের ক্ষেত্রে নিয়ম উল্টো: মান না দিলে C নিশ্চয়তা দেয় যে সংখ্যা হবে 0, দশমিক হবে 0.0, pointer হবে NULL, আর array বা struct-এর প্রতিটি ঘরও তাই। নিচের প্রোগ্রামে শুধু নিশ্চিত মানগুলোই ছাপা হচ্ছে — মান না দেওয়া local ছাপানোর চেষ্টা আমরা ইচ্ছে করেই করছি না, কারণ সেটি পড়াই undefined behavior.

#include <stdio.h>

int g_count;                 /* global, no initialiser: 0 */
static double g_rate;        /* file-private: 0.0 */
static int table[5];         /* every element: 0 */

int calls(void) {
    static int n;            /* static local: 0, set once */
    return ++n;
}

int main(void) {
    int local = 0;           /* automatic: we MUST give a value */
    static int *p;           /* static pointer: NULL */
    calls();
    calls();
    printf("g_count=%d g_rate=%.1f table[4]=%d\n", g_count, g_rate, table[4]);
    printf("calls=%d local=%d p is NULL: %s\n", calls(), local, p == NULL ? "yes" : "no");
    return 0;
}

৪ · Static local — যে ভ্যারিয়েবল মনে রাখে

হাসপাতালের বহির্বিভাগে (OPD) সকালে টিকিট কাউন্টারে লম্বা লাইন। কাউন্টারের মানুষটি প্রতিবার একটি সিরিয়াল নম্বর দেন — আগেরটির ঠিক পরেরটি। জরুরি বিভাগের কাউন্টারে আলাদা আরেকটি সিরিয়াল চলে, তার শুরু অন্য নম্বর থেকে। দুই কাউন্টারের কেউই অন্যের খাতায় হাত দেন না।

প্রোগ্রামে এই কাজের জন্য সবচেয়ে মানানসই হলো static local: নাম দেখা যায় শুধু ফাংশনের ভেতরে (scope ছোট), কিন্তু মান বেঁচে থাকে পুরো প্রোগ্রাম জুড়ে (আয়ু দীর্ঘ)। নিচের প্রোগ্রামে আরও দুটি জিনিস খেয়াল করুন — দুই ফাংশনেই last নামে ভ্যারিয়েবল আছে, আর main-এ একটি local total বাইরের global total-কে ঢেকে দিয়েছে:

#include <stdio.h>

int total = 0;                    /* file scope: tickets issued */

int opd_serial(void)       { static int last = 100; total++; return ++last; }
int emergency_serial(void) { static int last = 900; total++; return ++last; }

int main(void) {
    int a = opd_serial();
    int b = opd_serial();
    int c = emergency_serial();
    printf("OPD: %d %d, Emergency: %d\n", a, b, c);
    printf("Tickets issued (global total): %d\n", total);
    int total = a + b + c;        /* shadows the global from here on */
    printf("Sum of serials (local total): %d\n", total);
    return 0;
}

Static local কখন ভালো, কখন বিপদ

ভালো ব্যবহারের তালিকা ছোট কিন্তু কাজের: সিরিয়াল বা ID তৈরি, একবারই করতে হয় এমন প্রস্তুতি (“প্রথমবার ডাকা হলে টেবিল বানাও, পরে আর নয়”), ফাংশন কতবার ডাকা হলো তার হিসাব। প্রতিটি ক্ষেত্রেই সুবিধা হলো, স্মৃতিটি ফাংশনের ভেতরে লুকানো — বাইরের কেউ ভুল করে বদলাতে পারে না, যা global-এর চেয়ে অনেক নিরাপদ।

কিন্তু একটি দাম আছে। Static local মানে ফাংশনটির একটি গোপন স্মৃতি আছে, যা সবাই ভাগ করে নেয়। একই ইনপুটে ফাংশন একেক বার একেক ফল দেয়। দুটি thread একসাথে opd_serial() ডাকলে দুজনই একই নম্বর পেতে পারে (পর্ব ৪৯)। আর ফাংশনটি নিজের কাজ শেষ হওয়ার আগে আবার ডাকা হলে আগের কাজের অবস্থা নষ্ট হতে পারে — অর্থাৎ ফাংশনটি আর reentrant থাকে না। Standard library-র strtok এই সমস্যার বিখ্যাত উদাহরণ; ভাবনার প্রশ্নে বিস্তারিত দেখবেন।

৫ · Linkage — static, extern আর linker-এর হিসাব

বাস্তবের প্রোগ্রাম অনেকগুলো .c ফাইলে ভাগ করা থাকে, আর পর্ব ০৩-এ দেখেছেন প্রতিটি ফাইল আলাদাভাবে compile হয়ে .o হয়, শেষে linker সব জোড়া দেয়। তখন তৃতীয় প্রশ্নটি জরুরি হয়ে ওঠে: একটি ফাইলের নাম অন্য ফাইল দেখতে পায় কি না? উত্তর তিন রকম:

• External linkage: সব ফাইল দেখতে পারে। ফাংশনের বাইরে লেখা সাধারণ global ভ্যারিয়েবল আর সাধারণ ফাংশন — ডিফল্টভাবে এই দলে।
• Internal linkage: শুধু নিজের ফাইল দেখে। ফাংশনের বাইরে static লিখলে এটি হয়।
• No linkage: linker-এর সাথে কোনো সম্পর্কই নেই — সব local ভ্যারিয়েবল, এমনকি static local-ও।

এখানেই static শব্দের দ্বিতীয় অর্থ। ফাংশনের বাইরে static আয়ু বদলায় না (global-এর আয়ু এমনিতেই static), বদলায় শুধু linkage — “এই নাম আমার ফাইলের নিজস্ব।” আর extern লিখে বলা হয়: “এই নামের জিনিস আছে, তবে অন্য কোথাও তৈরি — আমি শুধু ব্যবহার করব।”

Linker আসলে কী দেখে? প্রতিটি .o ফাইলের ভেতরে একটি symbol-এর তালিকা থাকে, যা nm নামের টুল দিয়ে দেখা যায়। নিচে দুটি ফাইলের একটি ছোট প্রোগ্রাম — “পরে” চেপে linker-এর চোখ দিয়ে দেখুন:

int total = 0;               /* definition, external linkage */
static int calls;            /* internal: শুধু a.c-র */

static void log_call(void) { calls++; }   /* গোপন helper */

void add(int x) {
    log_call();
    total += x;
}

T add        /* বড় হাতের T: code, বাইরে খোলা */
b calls      /* ছোট হাতের b: bss, শুধু এই ফাইলের */
t log_call   /* ছোট হাতের t: code, শুধু এই ফাইলের */
B total      /* বড় হাতের B: bss, বাইরে খোলা */

#include <stdio.h>

extern int total;            /* declaration: আছে অন্য কোথাও */
void add(int x);             /* ফাংশনের prototype-ও declaration */

int main(void) {
    add(5);
    add(7);
    printf("total = %d\n", total);
    return 0;
}

U add
T main
U printf
U total

U total  (b.o)  →  B total  (a.o)   ✔
U add    (b.o)  →  T add    (a.o)   ✔
U printf (b.o)  →  libc             ✔
total = 12

/usr/bin/ld: b.o: multiple definition of `total';
a.o: first defined here
collect2: error: ld returned 1 exit status

/usr/bin/ld: b.o: undefined reference to `calls'
collect2: error: ld returned 1 exit status

Header-এ extern, একটি .c-তে definition

একটি global কয়েকটি ফাইলে লাগলে প্রতিটি ফাইলে আলাদা করে extern লেখা ঝুঁকিপূর্ণ — কোথাও টাইপ ভুল হলে compiler ধরতে পারবে না। পেশাদার নিয়মটি এরকম:

/* config.h  — সবাই এটি include করে */
extern int g_verbose;          /* declaration only */

/* config.c  — ঠিক একটি ফাইলে */
#include "config.h"
int g_verbose = 0;             /* the one definition */

সবাই config.h include করে বলে সবার কাছে একই declaration যায়, আর config.c নিজেও header include করায় compiler মিলিয়ে দেখতে পারে যে definition আর declaration-এর টাইপ এক। বিস্তারিত পর্ব ২৯-এ, মডুলার প্রোগ্রামে। দুটি বিপজ্জনক ভুল এখনই জেনে রাখুন:

• Header-এ int g_verbose = 0; লেখা: যত .c ফাইল header include করবে, ততগুলো definition তৈরি হবে — linker দেবে multiple definition.
• Header-এ static int g_verbose; লেখা: এটি আরও খারাপ, কারণ কোনো error আসে না! প্রতিটি .c ফাইল নিজের একটি গোপন কপি পায়। এক ফাইল মান বদলায়, অন্য ফাইল পুরোনো মান দেখে — নীরব বাগ।

৬ · auto, register আর _Thread_local — বাকি তিন শব্দ

“C-এর storage class কয়টি?” — পরীক্ষার প্রস্তুতিতে এটি একটি পরিচিত প্রশ্ন। পুরোনো বইয়ের উত্তর চারটি: auto, register, static, extern. আধুনিক C-তে আছে আরও একটি — _Thread_local (আর ব্যাকরণের সুবিধার জন্য typedef-কেও এই দলে গোনা হয়; C23-এ constexpr-ও এই তালিকায় যোগ হয়েছে)। আজকের দিনে auto আর register প্রায় কেউ লেখে না, কিন্তু অর্থ জানা দরকার।

৭ · মেমরির মানচিত্রে কে কোথায় — আর local-এর ঠিকানার ফাঁদ

এ পর্যন্ত যা শিখলেন, সব একটি ছবিতে আনা যায়। প্রোগ্রাম চালালে অপারেটিং সিস্টেম তাকে কয়েকটি ভাগে সাজানো একটি মেমরি-এলাকা দেয় — একে বলে memory map. পর্ব ২০-এ এটি বিস্তারিত দেখবেন; এখানে শুধু “কোন ভ্যারিয়েবল কোন ভাগে” প্রশ্নটির উত্তর:

BSS নিয়ে একটি মজার তথ্য: static int big[1000000]; লিখলেও আপনার প্রোগ্রাম ফাইল প্রায় একটুও বড় হয় না। কারণ ফাইলে লেখা থাকে শুধু “এত বাইট শূন্য জায়গা লাগবে”, আর প্রোগ্রাম খোলার সময় অপারেটিং সিস্টেম সেই জায়গা শূন্য দিয়ে ভরে দেয়। অন্যদিকে Data অংশের প্রতিটি মান ফাইলের ভেতরে আসলেই লেখা থাকে।

ফাংশন শেষ, বাক্সও শেষ — কিন্তু ঠিকানা রয়ে গেল

এখন একটি ক্লাসিক বাগ বোঝার সব উপকরণ আপনার হাতে। ফাংশন যদি নিজের local ভ্যারিয়েবলের ঠিকানা ফেরত দেয়, তাহলে কী হয়? & আর * চিহ্নের পুরো ব্যাখ্যা আসবে পর্ব ১৭-এ; এখন শুধু জানুন, &t মানে “t-এর ঠিকানা” আর *p মানে “p যে ঠিকানা ধরে আছে, সেখানে যা আছে”। ধাপে ধাপে দেখুন:

1#include <stdio.h>23int *make_token(void) {4    int t = 101;          // automatic5    return &t;            // বাগ!6}78void noisy(void) {9    int junk = 999;10    (void)junk;11}1213int main(void) {14    int *p = make_token();15    noisy();16    printf("%d\n", *p);   // ?17    return 0;18}

৮ · Global ভ্যারিয়েবল — সুবিধাজনক, কিন্তু দামি

নতুনরা প্রায়ই global ভালোবাসেন: parameter পাঠানোর ঝামেলা নেই, যেকোনো ফাংশন থেকে সরাসরি পড়া-লেখা যায়। ৫০ লাইনের প্রোগ্রামে এতে ক্ষতিও কম। কিন্তু প্রোগ্রাম ৫০ হাজার লাইনে পৌঁছালে একই সুবিধা পরিণত হয় সবচেয়ে বড় মাথাব্যথায়।

• লুকানো নির্ভরতা: int calc_fee(int days) দেখে মনে হয় ফল নির্ভর করে শুধু days-এর ওপর। কিন্তু ভেতরে যদি global g_rate পড়া হয়, তাহলে ফাংশনের মাথা মিথ্যা বলছে। একটি ফাংশন বদলালে অন্য কোথাও কিছু ভাঙে, আর কেউ বুঝতে পারে না দুটির মধ্যে সম্পর্ক কী।
• পরীক্ষা করা কঠিন: ফাংশনটি পরীক্ষা করতে হলে আগে সব প্রাসঙ্গিক global ঠিক অবস্থায় আনতে হয়, পরীক্ষা শেষে আবার আগের অবস্থায় ফেরাতে হয়। একটি পরীক্ষার ফল নির্ভর করে আগের পরীক্ষা কী রেখে গেছে তার ওপর (পর্ব ৩২)।
• একসাথে কাজ: দুটি thread একই global একসাথে বদলালে data race — ফল অনিশ্চিত (পর্ব ৪৯)।
• নামের সংঘাত: C-তে সব external নাম একটিমাত্র বিশাল তালিকায় থাকে। আপনার count আর অন্য কারও library-র count মিলে গেলে linker error, বা আরও খারাপ, ভুল জিনিসের সাথে জোড়া।

তাহলে কী করবেন? নিচের ক্রমে ভাবুন — প্রথম যেটি কাজ করে, সেটিই নিন:

1. ডেটা দরকার হলে parameter দিয়ে পাঠান, ফল দরকার হলে return দিয়ে নিন।
2. অনেকগুলো সম্পর্কিত মান একসাথে ঘুরলে একটি struct বানিয়ে তার ঠিকানা পাঠান (পর্ব ২২)।
3. একটি ফাংশনের নিজের স্মৃতি দরকার হলে static local.
4. একটি ফাইলের কয়েকটি ফাংশনের মধ্যে ভাগ করতে হলে file-scope static.
5. সত্যিই পুরো প্রোগ্রামে লাগলে তবেই external global — header-এ extern, একটি .c-তে definition, আর নামের আগে প্রজেক্টের prefix.

৯ · AI-এর যুগে scope ও storage

AI-কে “একটা ছোট inventory প্রোগ্রাম লিখে দাও” বললে খুব দ্রুত চলে এমন কোড পাবেন। কিন্তু খেয়াল করলে দেখবেন, scope আর storage নিয়ে কিছু ভুল বারবার ফিরে আসে — কারণ AI শিখেছে ইন্টারনেটের লাখো ছোট উদাহরণ থেকে, যেখানে “চলছে” ছিল যথেষ্ট, “বড় হলেও টিকবে” কেউ ভাবেনি।

AI সাধারণত যেসব scope ও storage-ভুল করে

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

• -Wall -Wextra -Wshadow দিয়ে compile করেছি, একটিও warning নেই
• ফাইলের মাথায় প্রতিটি global-এর জন্য নিজেকে জিজ্ঞেস করেছি — “এটি parameter হতে পারত না?”
• যেসব ফাংশন pointer ফেরত দেয়, প্রতিটির ক্ষেত্রে দেখেছি ঠিকানাটি কার — local, static, না heap?
• Header ফাইলে = চিহ্নসহ কোনো ভ্যারিয়েবল নেই, আর কোনো static ভ্যারিয়েবলও নেই
• nm দিয়ে .o ফাইল দেখে নিশ্চিত হয়েছি যে শুধু দরকারি নামগুলোই বড় হাতের অক্ষরে (বাইরে খোলা)
• -fsanitize=address দিয়ে চালিয়েছি — dangling pointer-এর মতো মেমরি-ভুল এতে প্রায়ই ধরা পড়ে (পর্ব ৩১)