ফাংশন পয়েন্টার ও callback — ফাংশনের ঠিকানা দিয়ে কাজ পাঠানো

১ · ফাংশনেরও একটি ঠিকানা আছে

পর্ব ১৭-এ দেখেছেন, প্রতিটি ভ্যারিয়েবল মেমরির কোনো একটি ঘরে থাকে, আর & দিয়ে সেই ঘরের ঠিকানা পাওয়া যায়। এবার একটি প্রশ্ন ভাবুন — আপনার লেখা ফাংশনগুলো কোথায় থাকে?

উত্তরটি পর্ব ২০-এর memory map-এ ছিল। প্রোগ্রাম চালানোর সময় operating system আপনার compile করা machine code মেমরির একটি অংশে বসায় — তার নাম text segment. প্রতিটি ফাংশন সেখানে একটি নির্দিষ্ট জায়গা থেকে শুরু হয়। অর্থাৎ ডেটার যেমন ঠিকানা আছে, কোডেরও তেমনি ঠিকানা আছে।

আপনি যখন add(2, 3) লেখেন, CPU আসলে করে: “add-এর ঠিকানায় লাফ দাও, কাজ শেষে ফিরে এসো।” সাধারণ ফাংশন কলে এই ঠিকানা compile বা link-এর সময়ই ঠিক হয়ে যায়। কিন্তু যদি ঠিকানাটি একটি ভ্যারিয়েবলে রাখা যায়? তাহলে কোন ফাংশন চলবে, সেটি প্রোগ্রাম চলার সময় বদলানো যাবে। এই ভ্যারিয়েবলের নামই function pointer.

C-তে ফাংশনের নাম লিখে বন্ধনী না দিলে সেটি নিজেই ফাংশনের ঠিকানা হয়ে যায় — যেমন array-র নাম তার প্রথম ঘরের ঠিকানা হয়ে যায় (পর্ব ১৮). তাই f = add; আর f = &add; একই কথা। ডাকার সময়ও f(2, 3) আর (*f)(2, 3) একই কাজ করে; আজকাল প্রথমটিই বেশি লেখা হয়।

২ · ভয় পাওয়ানো syntax — ভেতর থেকে বাইরে পড়ুন

Function pointer-এর ধারণা সহজ, কিন্তু লেখার ধরন প্রথম দেখায় ভয় পাওয়ায়। qsort-এর নিয়মের ফাংশনের জন্য যে ঘোষণা লাগে, সেটি দেখতে এমন:

int (*cmp)(const void *, const void *);

এটি পড়ার একটি সহজ কৌশল আছে: নাম থেকে শুরু করুন, তারপর ভেতর থেকে বাইরে আসুন। বন্ধনী যেখানে আছে, আগে সেটির ভেতরটা পড়ুন। নিচের ডায়াগ্রামে “পরে” চেপে দেখুন কোন অংশ কোন ক্রমে পড়তে হয়:

typedef — জটিল টাইপকে একটি সহজ নাম দেওয়া

পর্ব ২২-এ typedef দিয়ে struct-কে ছোট নাম দিয়েছিলেন। Function pointer-এর ক্ষেত্রে typedef আরও বেশি কাজের, কারণ একই লম্বা টাইপ বারবার লিখতে হয়। পেশাদার কোডে প্রায় সবসময় এভাবেই লেখা হয়:

৩ · qsort — সাজানোর কৌশল library-র, নিয়ম আপনার

ধরুন একটি কলেজের ভর্তি তালিকা বানাতে হবে। ছাত্রদের সাজাতে হবে GPA অনুযায়ী — বেশি GPA আগে। দুজনের GPA সমান হলে নামের বর্ণানুক্রমে। Sorting-এর algorithm নিজে লেখা ঝামেলার আর ভুলের ঝুঁকিও বেশি। C-এর standard library-তে আগে থেকেই একটি ফাংশন আছে — qsort.

কিন্তু একটা সমস্যা আছে। qsort লেখা হয়েছে কয়েক দশক আগে। সে আপনার Student struct চেনে না, GPA কী তা জানে না, “বেশি আগে” না “কম আগে” — তাও জানে না। তাহলে সে সাজাবে কীভাবে?

সমাধানটি সুন্দর: সাজানোর কৌশল (কোনটা কোথায় সরাতে হবে) qsort জানে; তুলনার নিয়ম (দুজনের মধ্যে কে আগে) আপনি একটি ফাংশন হিসেবে দেন। এই নিয়মের ফাংশনকে বলে comparator. qsort-এর ঘোষণা দেখুন:

void qsort(void *base, size_t count, size_t size,
           int (*compar)(const void *, const void *));

চারটি জিনিস লাগে: array কোথা থেকে শুরু, কয়টি উপাদান, প্রতিটি কত byte, আর তুলনার ফাংশনের ঠিকানা। qsort কাজের মাঝে বারবার আপনার ফাংশন ডাকে, প্রতিবার দুটি উপাদানের ঠিকানা দিয়ে। আপনার ফাংশন যা ফেরত দেয়, তা দেখে qsort সিদ্ধান্ত নেয়:

লক্ষ করুন, মানটি ঠিক −১ বা ১ হতে হবে এমন নয় — শুধু চিহ্নটি (ঋণাত্মক, শূন্য, ধনাত্মক) গুরুত্বপূর্ণ। এবার দেখুন চার জন ছাত্রের তালিকা সাজানোর সময় qsort কীভাবে আপনার comparator-কে বারবার ডাকে। (আসল qsort কোন algorithm ব্যবহার করবে, C standard তা বলে দেয়নি — library ভেদে আলাদা। এখানে বোঝার সুবিধার জন্য সবচেয়ে সহজ পদ্ধতি, insertion sort-এর মতো করে দেখানো হলো।)

1int by_gpa_then_name(const void *a, const void *b) {2    const Student *x = a, *y = b;3    if (x->gpa != y->gpa)4        return (x->gpa < y->gpa) - (x->gpa > y->gpa);5    return strcmp(x->name, y->name);6}

এবার আসল প্রোগ্রামটি চালিয়ে দেখুন। Comparator-টি হুবহু ওপরের মতো:

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

typedef struct { char name[16]; double gpa; } Student;

static int by_gpa_then_name(const void *a, const void *b) {
    const Student *x = a, *y = b;                  /* void* back to Student* */
    if (x->gpa != y->gpa)
        return (x->gpa < y->gpa) - (x->gpa > y->gpa); /* higher GPA first */
    return strcmp(x->name, y->name);               /* tie: A to Z */
}

int main(void) {
    Student s[] = { {"Rafi", 3.50}, {"Mitu", 3.90}, {"Anik", 3.50}, {"Tania", 3.75} };
    size_t n = sizeof s / sizeof s[0];
    qsort(s, n, sizeof s[0], by_gpa_then_name);    /* pass the rule, not a result */
    for (size_t i = 0; i < n; i++)
        printf("%zu. %-6s %.2f\n", i + 1, s[i].name, s[i].gpa);
    return 0;
}

৪ · Comparator-এর তিনটি ফাঁদ

Comparator দেখতে ছোট্ট একটি ফাংশন, কিন্তু এখানে ভুল হলে প্রোগ্রাম crash করে না — চুপচাপ ভুল ক্রমে সাজায়। আর ভুল তালিকা দেখে বোঝাই কঠিন যে গোলমালটা কোথায়। তিনটি ফাঁদ প্রায় সবাই একবার না একবার পড়েন:

ফাঁদ ১ — বিয়োগ করে ফল ফেরত দেওয়া

অনেক বই আর AI এভাবে লেখে: return *(const int *)a - *(const int *)b;. দেখতে চালাক — a বড় হলে ফল ধনাত্মক, ছোট হলে ঋণাত্মক। সাধারণ ছোট সংখ্যায় ঠিকই চলে। কিন্তু পর্ব ০৫-এর overflow মনে করুন। a = 2000000000 আর b = -2000000000 হলে আসল পার্থক্য চার শত কোটি, যা int-এ ধরে না। Signed int-এর overflow C-তে undefined behavior — বাস্তবে সাধারণত ফল উল্টো চিহ্নের হয়ে যায়, আর comparator বলে “বড়টি ছোট”.

return a - b;                 /* ঝুঁকিপূর্ণ: বড় মানে overflow */
return (a > b) - (a < b);     /* নিরাপদ: সবসময় -1, 0 বা 1 */

ফাঁদ ২ — ভুল cast বা ভুল টাইপ

• দশমিক কেটে যাওয়া: GPA-র জন্য কেউ লিখলেন return (int)(x->gpa - y->gpa);. ৩.৯০ − ৩.৫০ = ০.৪০, আর (int) করলে হয় 0 — অর্থাৎ comparator বলছে “দুজন সমান”! পুরো তালিকা প্রায় না-সাজানো থেকে যায়।
• ঠিকানার স্তর গুলিয়ে ফেলা: যদি array-তে struct না রেখে struct-এর pointer রাখেন (Student *list[]), তাহলে qsort comparator-কে দেবে “pointer-এর ঠিকানা”. তখন const Student *x = a; লিখলে ভুল — লাগবে const Student *x = *(const Student * const *)a;. কোনো warning আসবে না, কারণ void * থেকে যেকোনো ঠিকানায় রূপান্তর C নীরবে মেনে নেয়।
• Comparator-এর টাইপই বদলে দেওয়া: int cmp(const Student *, const Student *) লিখে cast করে qsort-কে দেওয়া। অনেক মেশিনে কাজ করে যায়, কিন্তু ভুল টাইপের ফাংশন পয়েন্টার দিয়ে ডাকা C standard অনুযায়ী undefined behavior. নিয়ম: parameter সবসময় const void *, cast ভেতরে।

ফাঁদ ৩ — অসংগত নিয়ম

Comparator-কে একটি সংগত নিয়ম মানতে হয়: a < b আর b < c হলে a < c হতেই হবে; আর একই জোড়া বারবার জিজ্ঞেস করলে একই উত্তর দিতে হবে। এলোমেলো সংখ্যা ফেরত দেওয়া, বা “সমান হলে কখনো −১ কখনো ১” — এমন নিয়ম qsort-কে বিভ্রান্ত করে। ফল হতে পারে ভুল ক্রম, এমনকি কিছু library-তে array-র সীমার বাইরে পড়া।

৫ · Dispatch table — লম্বা switch-এর বদলে ফাংশনের তালিকা

পর্ব ২৩-এর রহিম চাচার খাতার কথা মনে আছে? মেনু থেকে একটি নম্বর পড়ে switch দিয়ে ঠিক করা হতো কোন ফাংশন চলবে। তিন-চারটি অপশনে সেটি দিব্যি চলে। কিন্তু চাচা যদি বিশটি অপশন চান? তখন switch হয়ে যায় পাতা-ভর্তি case, আর প্রতিটি নতুন অপশনে দুই জায়গায় বদলাতে হয় — মেনুর লেখা আর switch.

Function pointer দিয়ে একটি পরিষ্কার বিকল্প আছে: সব কাজের ফাংশনের ঠিকানা একটি array-তে রাখুন। মেনুর নম্বর থেকে index বের করুন, তারপর table[i](...) — এক লাইনেই সঠিক কাজ। এই array-কে বলে dispatch table. পর্ব ১১-এ শুনেছিলেন, compiler নিজেও বড় switch-কে ভেতরে ভেতরে প্রায়ই একটি jump table-এ বদলে দেয় — এটি তারই হাতে লেখা রূপ।

এবার চালানো যায় এমন একটি ছোট সংস্করণ — চাচার ক্যাশবাক্সের হিসাব। ইনপুট আগে থেকেই দেওয়া, তাতে একটি ভুল অপশনও (7) আছে। “Run” চাপুন:

#include <stdio.h>
typedef void (*Action)(long *cash);

static void sale(long *c)    { long x; if (scanf("%ld", &x) == 1 && x > 0) *c += x; printf("Cash: %ld Tk\n", *c); }
static void expense(long *c) { long x; if (scanf("%ld", &x) == 1 && x > 0) *c -= x; printf("Cash: %ld Tk\n", *c); }
static void report(long *c)  { printf("Report: %ld Tk in the box\n", *c); }

static const Action table[] = { sale, expense, report };    /* menu 1, 2, 3 */
static const size_t N = sizeof table / sizeof table[0];
int main(void) {
    long cash = 0; int choice;
    for (;;) {
        printf("\n1) Sale  2) Expense  3) Report  0) Exit\n> ");
        if (scanf("%d", &choice) != 1 || choice == 0) break;
        if (choice < 1 || (size_t)choice > N) { puts("No such option."); continue; }
        table[choice - 1](&cash);           /* one line replaces the whole switch */
    }
    puts("Bye!");
    return 0;
}

৬ · Callback — “ঘটনা ঘটলে এই নম্বরে ফোন করবেন”

qsort-এ আপনার ফাংশন ডাকা হয়েছিল সঙ্গে সঙ্গে — qsort চলার মধ্যেই। Callback-এর আরেকটি, আরও শক্তিশালী রূপ আছে: আপনি আজ ঠিকানা জমা দেন, আর ডাকা হয় পরে — যখন কোনো ঘটনা ঘটে। কুরিয়ার কোম্পানির খাতায় ফোন নম্বর রেখে আসার মতো।

নিচে একটি ছোট্ট “কুরিয়ার library” কল্পনা করুন। Library-র কাজ পার্সেল আসার অপেক্ষা করা; পার্সেল এলে কী করতে হবে, সেটি আপনি জানেন। দেখুন নিয়ন্ত্রণ কীভাবে আপনার কোড থেকে library-তে যায়, আবার ফিরে আসে:

1/* আপনার কোড */2void on_arrive(const char *parcel) {3    printf("Got %s!\n", parcel);4}5int main(void) {6    courier_register(on_arrive);7    courier_run();8}9/* কুরিয়ার library-র ভেতরে */10static void (*saved)(const char *);11void courier_register(void (*cb)(const char *)) { saved = cb; }12void courier_run(void) {13    /* ... অপেক্ষা ... পার্সেল এলো ... */14    if (saved != NULL) saved("Parcel #42");15}

বাস্তবের সিস্টেমে callback কোথায় কোথায়

Callback-এর সাথে নিজের তথ্য পাঠানো — context pointer

একটি বাস্তব সমস্যা আছে। ধরুন একই callback দশটি আলাদা বাটনের জন্য, আর জানতে হবে কোন বাটন চাপা হলো। এজন্য ভালো C library-গুলো register করার সময় ফাংশনের সাথে একটি বাড়তি void * নেয়, আর callback ডাকার সময় সেটি হুবহু ফেরত দেয়। একে বলে context pointer (অনেক library-তে নাম user_data বা arg). POSIX thread তৈরির pthread_create-এ এই নকশাই দেখবেন: একটি ফাংশন, আর তার জন্য একটি void * তথ্য।

৭ · একই interface, ভিন্ন ভিন্ন driver — C-তে polymorphism

এবার সবচেয়ে বড় ধারণাটি। পর্ব ২২-এর শেষে Linux kernel-এর struct file_operations-এর নাম শুনেছিলেন। প্রশ্নটি হলো: Linux-এ “ফাইল পড়া” একটিই কাজ — read(). অথচ সেই “ফাইল” হতে পারে হার্ডডিস্কের একটি ডকুমেন্ট, একটি USB ডিভাইস, একটি serial port, বা কিবোর্ড। প্রতিটির ভেতরের কাজ সম্পূর্ণ আলাদা। Kernel একটি লাইনে সবাইকে সামলায় কীভাবে?

উত্তর: একটি struct, যার ভেতরে শুধু function pointer. Kernel ঠিক করে দেয় struct-এর আকার — কোন কোন কাজ থাকবে (read, write, open…). প্রতিটি driver সেই struct-এর একটি কপি বানিয়ে নিজের ফাংশনগুলোর ঠিকানা বসায়। Kernel শুধু জানে “এই ডিভাইসের struct-এর read ঘরে যে ঠিকানা আছে, সেটি ডাকো।” এই চুক্তিকেই বলে interface.

C-তে এর কোড দেখতে মোটামুটি এমন (সরল করা; আসল file_operations-এ আরও অনেক ঘর আছে):

struct file_ops {
    long (*read)(struct device *dev, char *buf, long n);
    long (*write)(struct device *dev, const char *buf, long n);
};

static const struct file_ops usb_ops = { .read = usb_read, .write = usb_write };

/* kernel-এর ভেতরে — কোন driver, তা জানার দরকার নেই */
long n = dev->ops->read(dev, buf, 512);

৮ · নিরাপত্তা — ভুল ঠিকানায় লাফ দিলে কী হয়

Function pointer-এর ক্ষমতা যেখানে, বিপদও সেখানে। একটি সাধারণ data pointer নষ্ট হলে আপনি ভুল মান পড়েন। কিন্তু function pointer নষ্ট হলে CPU ভুল কোড চালায় — আর সেটি অনেক বড় বিপদ।

শেষ সারিটি বিশেষভাবে দেখুন। পর্ব ১৯-তে buffer overflow দেখেছেন। ধরুন একটি struct-এ প্রথমে একটি নামের buffer, তার ঠিক পরে একটি function pointer. কেউ নামের জায়গায় অনেক লম্বা লেখা দিল, আর বাড়তি byte গিয়ে বসল function pointer-এর ঘরে। পরে প্রোগ্রাম যখন সেই pointer দিয়ে ডাকবে, CPU লাফ দেবে আক্রমণকারীর বেছে নেওয়া ঠিকানায়। কয়েক দশক ধরে বহু আক্রমণ ঠিক এই পথেই হয়েছে — function pointer, return address বা C++ object-এর vtable pointer বদলে দিয়ে।

আধুনিক প্রতিরক্ষা — Control-Flow Integrity

এই বিপদের বিরুদ্ধে কয়েক স্তরের পাহারা তৈরি হয়েছে। পর্ব ১৭-এর ASLR ঠিকানা এলোমেলো করে, যাতে আক্রমণকারী সহজে আন্দাজ করতে না পারে কোথায় লাফ দিতে হবে। আরেকটি শক্তিশালী ধারণা হলো Control-Flow Integrity (CFI). এর মূল চিন্তা সহজ:

বাস্তবে এটি কয়েকভাবে আসে: Clang compiler-এর CFI অপশন, Windows-এর Control Flow Guard, আর আধুনিক CPU-তে হার্ডওয়্যার সহায়তা — Intel-এর CET আর ARM-এর BTI, যেগুলো যাচাই করে যে indirect call গিয়ে পড়েছে একটি চিহ্নিত বৈধ শুরুর জায়গায়। এগুলোর বিস্তারিত এই কোর্সের বাইরে; মনে রাখার কথা হলো, function pointer এত গুরুত্বপূর্ণ নিশানা যে CPU নির্মাতারাও এর পাহারায় নতুন নির্দেশ যোগ করেছেন।

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

“qsort দিয়ে সাজাও” বা “মেনুটা function pointer দিয়ে করো” — AI এগুলো কয়েক সেকেন্ডে লিখে দেয়, আর কোড compile-ও হয়। সমস্যা হলো, এই বিষয়ের ভুলগুলো প্রায় কখনো compile-এর সময় ধরা পড়ে না। চলার সময়েও সাধারণ ইনপুটে চুপ থাকে, ধরা পড়ে শুধু বিশেষ ইনপুটে।

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

• Comparator-এ কোথাও বিয়োগ করে ফল ফেরত দেওয়া হয়নি; দশমিক মান int-এ কাটা হয়নি
• Comparator-এর parameter const void *, আর ভেতরের cast array-র আসল উপাদানের টাইপের সাথে মেলে (struct, নাকি struct-এর pointer?)
• কোনো ফাংশন পয়েন্টারকে অন্য টাইপে cast করে পাঠানো হয়নি
• প্রতিটি table[i]-এর আগে i-এর সীমা যাচাই আছে, আর table static const
• প্রতিটি ঐচ্ছিক callback ডাকার আগে NULL যাচাই আছে
• সমান মান, খুব কাছাকাছি মান আর চরম মান (INT_MAX, INT_MIN) দিয়ে নিজে চালিয়ে ক্রম মিলিয়েছি