উন্নত পয়েন্টার — const, restrict, volatile দিয়ে কম্পাইলারকে কথা দেওয়া

১ · নতুন মডিউল — অ্যালগরিদম থেকে মেশিনের কাছাকাছি

গত মডিউলে আমরা অ্যালগরিদম নিয়ে কাজ করেছি — sorting, DP, graph, কনটেস্টের কৌশল। সেখানে প্রশ্ন ছিল “কোন পদ্ধতিতে কম ধাপে উত্তর পাব?” এই মডিউল ৭, “সিস্টেম প্রোগ্রামিং”-এ প্রশ্ন বদলে যাচ্ছে: “আমার প্রোগ্রাম অপারেটিং সিস্টেম আর হার্ডওয়্যারের সাথে কীভাবে কথা বলে?” সামনের পর্বগুলোতে আসবে process, pipe, thread আর network socket.

কিন্তু OS আর হার্ডওয়্যারের কাছে যাওয়ার আগে একটি জিনিস পাকা করা দরকার — পয়েন্টার নিয়ে সূক্ষ্ম কথাবার্তা। পর্ব ১৭ ও ১৮-তে আপনি শিখেছেন pointer একটি ঠিকানা রাখে। এবার শিখবেন সেই ঠিকানা নিয়ে compiler-কে তিনটি বিশেষ কথা কীভাবে বলতে হয়।

C-তে এই স্টিকারগুলোর নাম type qualifier. এগুলো কোনো ভ্যারিয়েবলের আকার বা বিট বদলায় না। শুধু বলে দেয় — এই ডেটা কে বদলাতে পারবে, কার মাধ্যমে পৌঁছানো যাবে, আর এর মান কি প্রোগ্রামের অজান্তে বদলে যেতে পারে।

২ · const — কোন জিনিসে তালা, ডেটায় না পয়েন্টারে?

সাধারণ ভ্যারিয়েবলে const সহজ: const int max = 100; লিখলে max আর বদলানো যায় না। কিন্তু পয়েন্টারে দুটি আলাদা জিনিস আছে — পয়েন্টার নিজে (ঠিকানাটা কোথায় রাখা) আর যে ডেটার দিকে সে তাকিয়ে আছে। তাই তালাও দুই জায়গায় দেওয়া যায়।

মনে রাখার একটি ছোট কৌশল: *-চিহ্নকে দেয়াল ভাবুন। const দেয়ালের বাঁ পাশে থাকলে তালা ডেটায়, ডান পাশে (নামের ঠিক আগে) থাকলে তালা পয়েন্টারে। নিচের ডায়াগ্রামে সবচেয়ে কঠিন রূপটি নাম থেকে শুরু করে উল্টো দিকে শব্দ ধরে ধরে পড়ুন:

p হলো …

p হলো একটি const (বদলানো যায় না এমন) …

p হলো একটি const পয়েন্টার, যা তাকিয়ে আছে …

p হলো একটি const পয়েন্টার, যা তাকিয়ে আছে একটি int-এর দিকে …

p হলো একটি const পয়েন্টার, যা তাকিয়ে আছে
একটি const int-এর দিকে।

const int *const p = &x;

*p = 5;    /* error: ডেটায় তালা          */
p  = &y;   /* error: পয়েন্টারে তালা       */
int v = *p; /* চলবে: শুধু পড়া তো নিষেধ নয় */

এবার হাতে-কলমে দেখুন। নিচের কোডে তিন রকম পয়েন্টার আর একটি “const-সচেতন” ফাংশন আছে। যে লাইনগুলো compile হবে না, সেগুলো comment করে রাখা হয়েছে — চাইলে comment সরিয়ে error নিজের চোখে দেখুন।

#include <stdio.h>
static size_t count_char(const char *s, char c) {
    size_t n = 0;
    for (; *s != '\0'; s++)     /* s সরানো চলবে */
        if (*s == c) n++;
    /* *s = 'x';  error: read-only location */
    return n;
}
int main(void) {
    int a = 10, b = 20;
    const int *p = &a;         /* ডেটায় তালা */
    int *const q = &a;         /* পয়েন্টারে তালা */
    const int *const r = &b;   /* দুটোতেই তালা */
    p = &b;                    /* চলবে */
    *q = 15;                   /* চলবে: a এখন 15 */
    /* *p = 1;  q = &b;  *r = 2;   -- তিনটিই error */
    printf("*p=%d a=%d *r=%d\n", *p, a, *r);
    printf("count=%zu\n", count_char("banana", 'a'));
    return 0;
}

৩ · const যখন ফাংশনের চুক্তিপত্র

const-এর সবচেয়ে বড় ব্যবহার আসলে ফাংশনের parameter-এ। Standard library-র এই ঘোষণাটি দেখুন:

size_t strlen(const char *s);
char  *strcpy(char *dest, const char *src);

শুধু ঘোষণা পড়েই আপনি জানেন, strlen আপনার string-এ একটি অক্ষরও বদলাবে না। আর strcpy-তে src শুধু পড়া হবে, লেখা হবে dest-এ। কোড খুলে দেখার দরকার নেই — চুক্তিপত্রেই লেখা আছে। পর্ব ১৮-তে দেখা const pointer parameter-এর এটাই আসল শক্তি।

এই অভ্যাসের নাম const-correctness: যে পয়েন্টার দিয়ে লেখার কথা নয়, তার প্রতিটিতে const লিখুন। এর তিনটি লাভ:

• ভুল আগেই ধরা পড়ে। কেউ ভুল করে “শুধু পড়ার” ফাংশনে কিছু লিখে ফেললে compiler সঙ্গে সঙ্গে error দেয়।
• ফাংশন ব্যবহারকারী নিশ্চিন্ত থাকেন। আপনার ডেটা নিরাপদ কি না, তা ঘোষণা পড়েই বোঝা যায়।
• const ডেটাও পাঠানো যায়। const ছাড়া লেখা ফাংশনে একটি const string পাঠালে compiler warning দেয়। তাই একটি জায়গায় const বাদ পড়লে পুরো প্রজেক্টে সমস্যা ছড়ায় — বড় C প্রজেক্টে এজন্য শুরু থেকেই const-correctness মানা হয়।

String literal — const না লিখলেও আসলে “শুধু পড়ার”

C-তে char *s = "Dhaka"; লেখা বৈধ — compiler কিছু বলে না। কিন্তু এই string literal সাধারণত থাকে read-only memory-তে। s[0] = 'd'; লিখলে সেটি undefined behavior; বেশিরভাগ সিস্টেমে প্রোগ্রাম সেখানেই crash করে। ঐতিহাসিক কারণে C-তে string literal-এর টাইপ const char[] নয়, char[]; পুরোনো কোড ভেঙে যাবে বলে এটি আর বদলানো হয়নি। তাই নিজে সবসময় লিখুন const char *s = "Dhaka"; — তাহলে ভুল লেখা compiler-ই ধরবে।

const “ফেলে দেওয়া” — cast-এর ফাঁদ

একটি cast দিয়ে const সরিয়ে ফেলা যায়: char *w = (char *)s;. Compiler চুপ থাকে, কারণ আপনি জোর করে বলেছেন। এর ফল নির্ভর করে আসল object-এর ওপর:

৪ · জটিল ঘোষণা পড়ার নিয়ম

C-এর ঘোষণা কখনো কখনো ধাঁধার মতো দেখায়। কারণ C-এর একটি নকশা-নীতি: ঘোষণা দেখতে ব্যবহারের মতো। int *p মানে “*p একটি int”. int a[5] মানে “a[i] একটি int”. এই নীতি ছোট ঘোষণায় সুন্দর, কিন্তু বড় হলে জট পাকায়। তখন কাজে আসে right-left rule:

ডানে [ ] পেলে পড়ুন “array”, ( ) পেলে “ফাংশন”, বাঁয়ে * পেলে “পয়েন্টার”। দুটি দেখতে প্রায় একই ঘোষণা দিয়ে নিয়মটি পরখ করুন:

এবার একটু বড় একটি ঘোষণা — একটি function pointer, যে ফাংশন একটি পয়েন্টার ফেরত দেয়। নিয়ম মেনে ধাপে ধাপে পড়ুন:

fp হলো …

fp হলো একটি পয়েন্টার …

fp হলো একটি পয়েন্টার, এমন ফাংশনের দিকে যা একটি int নেয়
এবং ফেরত দেয় …

fp হলো একটি পয়েন্টার, এমন ফাংশনের দিকে যা একটি int নেয়
এবং ফেরত দেয় একটি পয়েন্টার …

fp হলো একটি পয়েন্টার, এমন ফাংশনের দিকে যা একটি int নেয়
এবং ফেরত দেয় একটি int-এর পয়েন্টার।

typedef int *Finder(int);   /* Finder = int নিয়ে int* দেয় এমন ফাংশন */
Finder *fp;                 /* fp = Finder-এর পয়েন্টার */

/* signal()-এর আসল ঘোষণা, typedef ছাড়া: */
void (*signal(int sig, void (*func)(int)))(int);
/* typedef দিয়ে: */
typedef void Handler(int);
Handler *signal(int sig, Handler *func);

৫ · Aliasing — একই মেমরির দুই নাম

restrict বোঝার আগে একটি সমস্যা বুঝতে হবে, যা compiler-এর জন্য সবচেয়ে বড় মাথাব্যথাগুলোর একটি। একটি মেমরির ঘরে যদি দুটি আলাদা পয়েন্টার দিয়ে পৌঁছানো যায়, সেই অবস্থার নাম aliasing, বাংলায় বলা যায় “একই ঘরের দুই নাম”।

একটি ছোট ফাংশন দেখুন:

void update(int *x, int *y) {
    *x = 1;
    *y = 2;
    printf("%d\n", *x);   /* 1 ছাপবে? */
}

মনে হয় *x তো সবে 1 করা হলো, তাই 1 ছাপবে — compiler সরাসরি 1 বসিয়ে দিলেই পারে। কিন্তু কেউ যদি update(&n, &n) ডাকে? তখন x আর y একই ঘর, আর *y = 2 লেখার পর *x-ও 2. তাই compiler-কে মেমরি থেকে *x আবার পড়তে হয়। এই “আবার পড়া” ছোট মনে হলেও লক্ষ-কোটিবার চলা লুপে সেটি গতির বড় বাধা।

Strict aliasing — টাইপ দিয়ে compiler-এর অনুমান

C-এর নিয়ম compiler-কে একটু সাহায্য করে। Strict aliasing rule বলে: একটি object-কে শুধু তার নিজের টাইপের (বা সামঞ্জস্যপূর্ণ টাইপের) পয়েন্টার দিয়েই পড়া-লেখা করা যাবে। তাই int * আর float * একই ঘর দেখাবে না — compiler এটি ধরে নেয়, আর GCC-তে -O2 চালু করলে এই অনুমান কাজে লাগিয়ে optimization করে।

একই বাইটকে এক টাইপে লিখে আরেক টাইপে পড়ার এই কাজের নাম type punning, যা পর্ব ২২-এ union-এর সাথে দেখেছেন। নিয়মের দুটি বড় ব্যতিক্রম মনে রাখুন। এক: char * (আর unsigned char *) দিয়ে যেকোনো object-এর বাইট পড়া যায় — এজন্যই memcpy কাজ করে। দুই: C-তে (C++-এ নয়) union-এর এক সদস্যে লিখে অন্য সদস্যে পড়া অনুমোদিত।

৬ · restrict — “এই মেমরিতে আর কেউ হাত দেবে না”

Aliasing-এর সমস্যার সরাসরি সমাধান restrict. কোনো পয়েন্টারে restrict লিখে আপনি প্রতিশ্রুতি দেন: “এই পয়েন্টার যতক্ষণ বেঁচে আছে, এর দেখানো মেমরিতে অন্য কোনো পথে কেউ পৌঁছাবে না।” Compiler এটি যাচাই করে না — বিশ্বাস করে, আর সেই বিশ্বাসে দ্রুত কোড বানায়।

একটি লুপ দিয়ে দেখি। ফাংশনটি array b-এর প্রতিটি ঘরে *a-র মান যোগ করে। একটি অদ্ভুত কিন্তু বৈধ ডাক দিয়ে চালাচ্ছি — a দেখাচ্ছে b-এরই একটি ঘর। “পরে” চাপুন আর array-র মান খেয়াল করুন:

1void add_all(int *b, const int *a, int n) {2    for (int i = 0; i < n; i++)3        b[i] += *a;4}56int arr[4] = {1, 1, 1, 1};7add_all(arr, &arr[1], 4);

memcpy বনাম memmove — restrict-এর সবচেয়ে বিখ্যাত উদাহরণ

C99 থেকে standard library-তে এই দুটি ফাংশনের ঘোষণা এমন:

void *memcpy (void *restrict dest, const void *restrict src, size_t n);
void *memmove(void *dest,          const void *src,          size_t n);

পার্থক্য শুধু restrict শব্দে, কিন্তু অর্থে অনেক বড়। memcpy বলছে: “উৎস আর গন্তব্য একটির ওপর আরেকটি পড়বে না — পড়লে দায় আপনার।” তাই সে যেকোনো ক্রমে, যত দ্রুত সম্ভব কপি করে। memmove এমন কোনো প্রতিশ্রুতি চায় না — জায়গা overlap করলে সে পেছন দিক থেকে কপি করে বা অন্য কৌশলে সঠিক ফল দেয়।

নিচের কোডে একটি string-এর প্রথম ৫টি অক্ষর ২ ঘর ডানে সরাতে চাই — উৎস আর গন্তব্য একে অপরের ওপর পড়ছে। একই কাজ একবার সাধারণ সামনের দিকের লুপে, একবার memmove দিয়ে:

#include <stdio.h>
#include <string.h>

int main(void) {
    char a[] = "ABCDEFGH";
    char b[] = "ABCDEFGH";

    /* লক্ষ্য: প্রথম 5টি অক্ষর 2 ঘর ডানে -> "ABABCDEH" */
    for (int i = 0; i < 5; i++)      /* সামনে থেকে কপি */
        a[2 + i] = a[i];

    memmove(b + 2, b, 5);            /* overlap হলেও নিরাপদ */
    /* memcpy(b + 2, b, 5);  এখানে undefined behavior */

    printf("forward loop: %s\n", a);
    printf("memmove     : %s\n", b);
    return 0;
}

৭ · volatile — “এই মান পেছন থেকে বদলাতে পারে”

এতক্ষণ compiler-এর একটি অনুমান কাজে লাগাচ্ছিলাম: “মেমরির মান বদলায় শুধু আমার প্রোগ্রাম লিখলে।” সাধারণ প্রোগ্রামে এটি সত্য। কিন্তু embedded system-এ তা নয়। একটি microcontroller-এ (যেমন একটি স্মার্ট মিটার বা গার্মেন্টসের সেলাই-মেশিনের কন্ট্রোলার) সেন্সর, টাইমার, LED — সব যন্ত্র কিছু নির্দিষ্ট মেমরি-ঠিকানার সাথে যুক্ত। একে বলে memory-mapped I/O.

এই হার্ডওয়্যার register-এর মান প্রোগ্রামের অজান্তে বদলায়। আর এখানেই compiler-এর অনুমান বিপদ ডেকে আনে। নিচে একটি polling লুপ — সেন্সর “ready” না হওয়া পর্যন্ত অপেক্ষা:

#define READY  0x1u
#define STATUS (*(uint32_t *)0x40000000u)

while ((STATUS & READY) == 0) { }   /* অপেক্ষা */
read_temperature();

    ldr  r1, [r0]       ; STATUS একবারই পড়া হলো
    tst  r1, #1
    bne  done
hang:
    b    hang           ; আর কখনো পড়ে না!
done:

#define READY  0x1u
#define STATUS (*(volatile uint32_t *)0x40000000u)

while ((STATUS & READY) == 0) { }
read_temperature();

wait:
    ldr  r1, [r0]       ; প্রতিবার আসল পড়া
    tst  r1, #1
    beq  wait
    bl   read_temperature

#define LED (*(volatile uint32_t *)0x40000004u)

LED = 1;   /* বাতি জ্বলো    */
LED = 0;   /* বাতি নেভো    */
/* volatile না থাকলে compiler প্রথম লেখাটি
   "অকারণ" ভেবে মুছে দিতে পারত */

Signal handler আর volatile sig_atomic_t

volatile-এর দ্বিতীয় বৈধ ব্যবহার signal handler. ব্যবহারকারী Ctrl+C চাপলে OS প্রোগ্রামকে SIGINT পাঠায়, আর প্রোগ্রামের যেকোনো জায়গা থেকে মাঝপথে handler ফাংশনটি চলে যায়। মূল লুপ যদি একটি flag দেখে থামার অপেক্ষায় থাকে, সেই flag হতে হবে এমন:

static volatile sig_atomic_t stop = 0;

void on_ctrl_c(int sig) { (void)sig; stop = 1; }   /* handler */

while (!stop) { do_work(); }                         /* মূল লুপ */

এখানে দুটি অংশ দুটি আলাদা কাজ করে। volatile নিশ্চিত করে মূল লুপ প্রতিবার stop নতুন করে পড়বে। আর sig_atomic_t এমন একটি টাইপ, যার মান লেখা signal এসে মাঝপথে থামালেও অর্ধেক লেখা অবস্থায় থাকে না। C standard বলে, asynchronous signal handler থেকে নিরাপদে লেখা যায় শুধু এমন volatile sig_atomic_t object-এ। Handler-এর ভেতরে printf বা malloc ডাকাও নিরাপদ নয় — পর্ব ৪৮-এ process আর signal নিয়ে আরও দেখব।

৮ · সবচেয়ে বড় ভুল ধারণা — volatile thread-এর ওষুধ নয়

ইন্টারনেটে, পুরোনো বইয়ে, এমনকি AI-এর উত্তরে প্রায়ই দেখবেন: “দুটি thread একটি ভ্যারিয়েবল ভাগ করলে সেটিকে volatile করুন।” C-তে এটি ভুল। কারণটা বুঝতে একটি bKash অ্যাকাউন্টের কথা ভাবুন, যেটি দুজন একসাথে দুটি ফোন থেকে ব্যবহার করছেন।

তাহলে কী ব্যবহার করবেন? C11 থেকে <stdatomic.h>-এ আছে _Atomic টাইপ ও atomic_fetch_add-এর মতো ফাংশন, যা atomicity আর ordering দুটোই দেয়। বড় অংশ রক্ষা করতে আছে mutex. পর্ব ৪৯-এ এগুলো বিস্তারিত দেখব। আর এই ধরনের বাগের নাম race condition — যা পর্ব ৪৯-এর মূল শত্রু।

বাস্তব জগতে এই তিন qualifier

৯ · AI-এর যুগে — qualifier-এর ভুল ধরা

AI খুব দ্রুত চলনসই সিস্টেম-কোড লেখে। কিন্তু qualifier-এর ভুলগুলো compile-এর সময় প্রায় কখনো ধরা পড়ে না — প্রোগ্রাম চলে, পরীক্ষাতেও পাশ করে, তারপর অন্য compiler, অন্য optimization বা অন্য হার্ডওয়্যারে গিয়ে ভাঙে। এজন্য এগুলো আপনাকে চোখে দেখে চিনতে হবে।

AI সাধারণত যেসব ভুল করে

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

• যে পয়েন্টার দিয়ে শুধু পড়া হয়, তার প্রতিটিতে const আছে
• কোথাও cast দিয়ে const সরানো হয়নি — হলে আসল ডেটা লেখা যায় কি না নিশ্চিত হয়েছি
• প্রতিটি memcpy-তে overlap অসম্ভব; সন্দেহ থাকলে memmove
• volatile আছে শুধু হার্ডওয়্যার রেজিস্টার বা volatile sig_atomic_t flag-এ; thread-এর জন্য atomic বা mutex
• -O0 আর -O2 দুভাবেই চালিয়ে একই ফল পেয়েছি; ফল আলাদা হলে aliasing বা volatile-এর ভুল খুঁজেছি

int f(int *i, float *x) {
    *i = 1;
    *x = 0.0f;
    return *i;   /* compiler: "int আর float একই ঘর হতে পারে না" -> সরাসরি 1 */
}