ফাংশন — বড় কাজকে ছোট ছোট দায়িত্বে ভাগ করা

১ · ফাংশন কেন — এক রান্নাঘরে সবাই সব কাজ করলে কী হয়

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

পর্ব ০২-এ আমরা শিখেছিলাম decomposition — বড় সমস্যাকে ছোট ছোট টুকরোয় ভাঙা। ফাংশন হলো C-তে সেই ভাঙাকে কোডে রূপ দেওয়ার যন্ত্র। আপনি এতদিন ধরে ফাংশন ব্যবহার করেই আসছেন: main নিজে একটি ফাংশন, আর printf-ও একটি ফাংশন, যা অন্য কেউ লিখে রেখেছেন। এই পর্বে আপনি নিজের ফাংশন বানাবেন — আর বুঝবেন ভেতরে কী ঘটে।

ফাংশনে ভাগ করার চারটি লাভ

২ · একটি ফাংশনের গঠন — নাম, ইনপুট আর ফলাফল

একটি ফাংশনের চারটি অংশ থাকে। নিচের ফাংশনটি একটি দামের ওপর ১৫% VAT যোগ করে মোট দাম ফেরত দেয়:

double apply_vat(double amount) {     // মাথা: return type, নাম, parameter
    double vat = amount * 0.15;       // শরীর: আসল কাজ
    return amount + vat;              // ফলাফল ফেরত
}

Parameter আর argument — একই জিনিস নয়

এই দুটি শব্দ নতুনরা প্রায়ই গুলিয়ে ফেলেন। Parameter হলো ফাংশনের সংজ্ঞায় লেখা খালি ঘর — amount. Argument হলো ডাকার সময় আসলে যে মান পাঠানো হয় — apply_vat(500.0) লিখলে 500.0 হলো argument. রেস্টুরেন্টের ভাষায়: অর্ডার স্লিপে ছাপানো “আইটেম: ____” ঘরটি parameter, আর ওয়েটার সেখানে যে “২ প্লেট কাচ্চি” লিখলেন সেটি argument.

যে ফাংশন কিছু ফেরত দেয় না — void

কিছু ফাংশনের কাজ শুধু একটি কাজ করা, কোনো মান ফেরত দেওয়া নয় — যেমন একটি রসিদ ছাপানো। এদের return type লেখা হয় void (অর্থ “কিছুই না”)। এমন ফাংশনকে বলে void function. আবার কোনো ফাংশন যদি কোনো ইনপুটই না নেয়, তবে parameter-এর জায়গায়ও void লেখা ভালো অভ্যাস, যেমন void print_header(void).

ডাকা আর ফেরা

double total = apply_vat(500.0); — এই লাইনটি একটি function call. প্রোগ্রাম তখন main-এর কাজ থামিয়ে apply_vat-এর ভেতরে চলে যায়, কাজ শেষ করে, তারপর ঠিক ওই লাইনেই ফিরে আসে এবং ফলাফল total-এ রাখে। “ঠিক ওই লাইনেই ফেরা” কীভাবে সম্ভব? এর উত্তর অংশ ৪-এ, call stack-এ।

৩ · Prototype — compiler-কে আগে থেকে জানিয়ে রাখা

Compiler আপনার ফাইল ওপর থেকে নিচে, একবারে একটি লাইন করে পড়ে। ধরুন main ফাইলের ওপরে আছে, আর apply_vat লেখা আছে নিচে। Compiler যখন main-এর ভেতরে apply_vat(500.0) দেখে, তখন সে এই নাম কখনো শোনেনি। কী ফেরত দেয়? কয়টি argument নেয়? কিছুই জানে না।

bill.c:5:20: error: implicit declaration of function 'apply_vat' [-Wimplicit-function-declaration]

পর্ব ০৪-এ আমরা এই implicit declaration সমস্যাটি দেখেছিলাম। খুব পুরোনো C-তে compiler চুপচাপ ধরে নিত “অচেনা ফাংশন নিশ্চয়ই int ফেরত দেয়।” আমাদের ফাংশন কিন্তু double ফেরত দেয় — ফলে ভুল সংখ্যা আসত, কোনো সতর্কতা ছাড়াই। C99 থেকে নিয়মটি বাদ দেওয়া হয়েছে, আর নতুন GCC (version 14 থেকে) একে সরাসরি error হিসেবে দেখায়।

সমাধান হলো function prototype — ফাংশনের মাথাটুকু, শেষে সেমিকোলন, শরীর ছাড়া। এটি compiler-কে বলে, “এই নামের একটি ফাংশন আছে, এই ইনপুট নেয়, এই ফল দেয়। পুরো কোড পরে আসছে।”

নিচের প্রোগ্রামে দুটি ফাংশন আছে — একটি ছাড় (discount) কাটে, অন্যটি VAT যোগ করে। খেয়াল করুন, ওপরে prototype আর নিচে function definition. main পড়লেই পুরো গল্পটা বোঝা যায়, ভেতরের অঙ্ক না দেখেই।

#include <stdio.h>

double apply_discount(double amount, double percent);   /* prototype */
double apply_vat(double amount);                         /* prototype */

int main(void) {
    double price = 1200.0;
    double after_discount = apply_discount(price, 10.0);
    double total = apply_vat(after_discount);
    printf("Price: %.2f\nAfter discount: %.2f\nTotal with VAT: %.2f\n",
           price, after_discount, total);
    return 0;
}

double apply_discount(double amount, double percent) {
    return amount - amount * percent / 100.0;
}

double apply_vat(double amount) {
    return amount * 1.15;
}

৪ · Call stack — ফাংশন ডাকলে মেমরিতে কী ঘটে

একটি ফাংশন আরেকটিকে ডাকে, সেটি আবার আরেকটিকে। প্রত্যেকে কাজ শেষে ঠিক যেখান থেকে ডাকা হয়েছিল সেখানেই ফেরে। প্রতিটির নিজের ভ্যারিয়েবল আছে, যা অন্যের সাথে মিশে যায় না। এই হিসাব রাখে মেমরির একটি অংশ — call stack.

প্রতিটি stack frame-এ তিনটি জিনিস থাকে: ফাংশনের parameter (পাঠানো মানের কপি), তার local variable, আর return address — কাজ শেষে কোন লাইনে ফিরতে হবে। নিচের প্রোগ্রামে main ডাকে calc_total-কে, আর সে ডাকে apply_vat-কে। “পরে” চাপুন এবং ডান দিকে stack কীভাবে বাড়ে আর কমে, খেয়াল করুন:

1#include <stdio.h>23double apply_vat(double amount) {4    double vat = amount * 0.15;5    return amount + vat;6}78double calc_total(int qty, double price) {9    double subtotal = qty * price;10    return apply_vat(subtotal);11}1213int main(void) {14    double bill = calc_total(2, 50.0);15    printf("bill = %.2f\n", bill);16    return 0;17}

এখান থেকে দুটি গুরুত্বপূর্ণ কথা বোঝা যায়। প্রথমত, ফাংশন শেষ হলেই তার local ভ্যারিয়েবল মুছে যায় — তাই পরের বার ডাকলে আগের মান পাওয়া যায় না। দ্বিতীয়ত, stack-এর জায়গা সীমিত। Linux-এ সাধারণত ৮ MB, Windows-এ ডিফল্ট ১ MB. কোনো ফাংশন যদি না থেমে নিজেকে বা একে অপরকে বারবার ডাকতে থাকে, frame জমতে জমতে জায়গা ফুরিয়ে যায় — একে বলে stack overflow, আর প্রোগ্রাম crash করে। পর্ব ১৫-এ recursion শেখার সময় এটি আবার দেখা হবে।

৫ · Pass by value — ফাংশন পায় শুধু কপি

Call stack-এর ছবিতে একটি কথা লক্ষ করেছেন? Argument-এর কপি গিয়ে বসে parameter-এ। C-তে argument পাঠানোর এই নিয়মকে বলে pass by value. এর সবচেয়ে বিখ্যাত ফল হলো নিচের ভুলটি।

ধরুন আপনি দুটি ভ্যারিয়েবলের মান অদলবদল (swap) করার একটি ফাংশন লিখলেন। দেখতে একদম ঠিক। কিন্তু ধাপে ধাপে দেখুন কী ঘটে:

1#include <stdio.h>23void swap(int a, int b) {4    int t = a;5    a = b;6    b = t;7}89int main(void) {10    int x = 5, y = 9;11    swap(x, y);12    printf("x=%d y=%d\n", x, y);13    return 0;14}

৬ · Scope ও lifetime — কোন নাম কোথায় দেখা যায়, কতক্ষণ বাঁচে

প্রতিটি ভ্যারিয়েবলের দুটি আলাদা বৈশিষ্ট্য আছে, যা নতুনরা প্রায়ই এক করে ফেলেন:

C-তে scope-এর দুটি প্রধান স্তর

• Block scope: { }-এর ভেতরে ঘোষণা করা নাম শুধু সেই block-এর ভেতরেই দেখা যায় — ঘোষণার লাইন থেকে block শেষ হওয়া পর্যন্ত। ফাংশনের শরীরও একটি block, তাই ফাংশনের parameter ও local ভ্যারিয়েবল এই স্তরে পড়ে। লুপের for (int i = 0; …)-এর i-ও তাই লুপের বাইরে অচেনা — পর্ব ১২-এ যা দেখেছেন।
• File scope: সব ফাংশনের বাইরে ঘোষণা করা নাম ঘোষণার জায়গা থেকে ফাইলের শেষ পর্যন্ত সব ফাংশন দেখতে পায়। এগুলোকেই সাধারণত global variable বলা হয়।

(C মানে আরও দুটি scope আছে — goto-র label-এর জন্য “function scope”, আর prototype-এর parameter নামের জন্য “function prototype scope”. সাধারণ ভ্যারিয়েবলের কাজে এগুলো নিয়ে ভাবতে হয় না; পরের পর্বে চারটিই পাশাপাশি দেখবেন।)

একই নাম যদি বাইরে আর ভেতরে দুই জায়গাতেই ঘোষণা করা হয়, তখন কী হয়? ভেতরেরটি বাইরেরটিকে ঢেকে দেয় — একে বলে shadowing. নিচের প্রোগ্রামে level নামে তিনটি আলাদা ভ্যারিয়েবল আছে। প্রতিটি printf কোনটিকে দেখছে, ধাপে ধাপে দেখুন:

1#include <stdio.h>23int level = 1;               // file scope45int main(void) {6    printf("A: %d\n", level);7    int level = 2;           // main-এর নিজের8    printf("B: %d\n", level);9    {10        int level = 3;       // ভেতরের block-এর11        printf("C: %d\n", level);12    }13    printf("D: %d\n", level);14    return 0;15}

Lifetime — তিনটি প্রধান আয়ু

সাধারণ local ভ্যারিয়েবলকে বলে automatic variable, কারণ এগুলো stack frame-এর সাথে নিজে থেকে তৈরি হয় আর নিজে থেকে মুছে যায়। এর একটি বিপজ্জনক ফল আছে: ফাংশন থেকে কখনো তার local ভ্যারিয়েবলের ঠিকানা ফেরত দেবেন না — frame মুছে যাওয়ার পর সেই ঠিকানায় যা থাকবে তা আবর্জনা। Pointer শেখার সময় এই ভুলটি আবার দেখব।

৭ · static, extern আর global ভ্যারিয়েবলের বিপদ

একটি ভ্যারিয়েবল কোথায় থাকবে, কতক্ষণ বাঁচবে আর অন্য ফাইল থেকে দেখা যাবে কি না — এই তিনটি ঠিক করে তার storage class. দুটি keyword এখানে সবচেয়ে গুরুত্বপূর্ণ: static আর extern.

ফাংশনের ভেতরে static — স্মৃতিওয়ালা ভ্যারিয়েবল

সাধারণ local ভ্যারিয়েবল প্রতিবার ফাংশন ডাকলে নতুন করে জন্মায়, আগের কিছু মনে রাখে না। কিন্তু local ভ্যারিয়েবলের আগে static লিখলে সে stack-এ না থেকে প্রোগ্রামের স্থায়ী মেমরিতে থাকে। ফলে ফাংশন শেষ হলেও তার মান থেকে যায়। এটিই static variable. নিচে একই ফাংশন তিনবার ডেকে দুই রকম ভ্যারিয়েবলের তুলনা দেখুন:

1#include <stdio.h>23void visit(void) {4    int normal = 0;5    static int count = 0;6    normal++;7    count++;8    printf("normal=%d count=%d\n", normal, count);9}1011int main(void) {12    visit();13    visit();14    visit();15    return 0;16}

বাস্তবে এর একটি চমৎকার ব্যবহার হলো সিরিয়াল নম্বর দেওয়া — যেমন ব্যাংকের কাউন্টারে টোকেন মেশিন। প্রতিবার বোতাম চাপলে আগের নম্বরের পরেরটি দেয়। নিচের প্রোগ্রামটি চালিয়ে দেখুন:

#include <stdio.h>

int next_token(void) {
    static int last = 100;   /* set once, remembered between calls */
    last++;
    return last;
}

int main(void) {
    for (int i = 0; i < 3; i++) {
        printf("Your token: %d\n", next_token());
    }
    return 0;
}

ফাইলের স্তরে static, আর extern

সব ফাংশনের বাইরে static লিখলে অর্থ বদলে যায়: তখন সেটি বলে “এই ভ্যারিয়েবল বা ফাংশন শুধু এই ফাইলের নিজস্ব — অন্য ফাইল একে দেখতে পাবে না।” আর extern ঠিক উল্টো কাজ করে: “এই নামের জিনিস আছে, তবে অন্য কোনো ফাইলে তৈরি করা।” পর্ব ০৩-এর separate compilation মনে করুন — এই দুটি keyword ঠিক করে কোন নাম linker-এর কাছে দৃশ্যমান হবে। এই নিয়মকে বলে linkage.

Global ভ্যারিয়েবল কেন বড় প্রোগ্রামে বিপদ

ছোট প্রোগ্রামে global ভ্যারিয়েবল খুব সুবিধাজনক মনে হয় — parameter পাঠানোর ঝামেলা নেই, সবাই সরাসরি ব্যবহার করে। কিন্তু প্রোগ্রাম বড় হলে এটিই সবচেয়ে বড় মাথাব্যথা হয়ে ওঠে:

• কে বদলাল? পঞ্চাশটি ফাংশন একটি global পড়ে ও বদলায়। মান ভুল এলে সন্দেহভাজন পঞ্চাশজন — প্রতিটি খুঁজে দেখতে হবে।
• লুকানো নির্ভরতা: ফাংশনের মাথা দেখে বোঝা যায় না সে কোন global ব্যবহার করে। Interface মিথ্যা বলে।
• পরীক্ষা কঠিন: একই ইনপুটে ফাংশন ভিন্ন ফল দিতে পারে, কারণ ফল নির্ভর করছে global-এর তখনকার মানের ওপর।
• একসাথে কাজ (thread): পর্ব ৪৯-এ দেখবেন, দুটি thread একই global একসাথে বদলালে ফল অনিশ্চিত হয়ে যায়।

নিয়মটি সহজ: ডেটা দরকার হলে parameter দিয়ে পাঠান, ফল দরকার হলে return দিয়ে নিন। স্মৃতি দরকার হলে আগে static local ভাবুন। Global রাখুন শেষ উপায় হিসেবে, আর রাখলে অন্তত ফাইলের স্তরে static দিয়ে তার নাগাল ছোট করুন।

৮ · ভালো ফাংশনের নকশা — পাঁচটি নিয়ম

ফাংশন লিখতে পারা আর ভালো ফাংশন লিখতে পারা — দুটি আলাদা দক্ষতা। অভিজ্ঞ প্রোগ্রামাররা নিচের নিয়মগুলো প্রায় অভ্যাসে মেনে চলেন:

১. একটি ফাংশন, একটি দায়িত্ব

এটিকে বলে single responsibility নীতি। পরীক্ষা সহজ: ফাংশনটি কী করে, এক বাক্যে বলুন। বাক্যে যদি “এবং” আসে — “ইনপুট নেয় এবং হিসাব করে এবং ফাইলে লেখে” — তবে ফাংশনটি তিনটি হওয়া উচিত। রেস্টুরেন্টের ওয়েটার রান্না করেন না; ঠিক এই কারণেই রান্নাঘর চলে।

২. নাম দিয়েই বোঝান

calc(), do_it(), func2() — এমন নাম কিছুই বলে না। ভালো নাম একটি ক্রিয়া দিয়ে শুরু হয় আর কাজটি স্পষ্ট করে: apply_vat, is_valid_phone, print_receipt. যে ফাংশন হ্যাঁ/না উত্তর দেয়, তার নাম সাধারণত is_ বা has_ দিয়ে শুরু হয়।

৩. ছোট রাখুন

Linux kernel-এর কোডিং নির্দেশিকায় লেখা আছে, ফাংশন হবে ছোট, একটি কাজ করবে, আর এক-দুই স্ক্রিনের মধ্যে ধরে যাবে। কোনো ফাংশন যদি পড়তে গিয়ে বারবার ওপরে-নিচে স্ক্রল করতে হয়, সেটি ভাঙার সময় হয়েছে। প্রতিটি ছোট অংশ আলাদা নামের ফাংশনে নিন।

৪. পারলে pure রাখুন

যে ফাংশন শুধু ইনপুট নিয়ে হিসাব করে ফল ফেরত দেয় — স্ক্রিনে কিছু লেখে না, global বদলায় না, ফাইলে হাত দেয় না — তাকে বলে pure function. apply_vat এমন একটি ফাংশন: 100 দিলে সবসময় 115, পৃথিবীর আর কিছু বদলায় না। অন্যদিকে স্ক্রিনে ছাপানো, ফাইলে লেখা বা global বদলানো হলো side effect. Side effect খারাপ নয় — এগুলো ছাড়া প্রোগ্রাম কিছুই দেখাতে পারত না। কিন্তু ভালো নকশায় হিসাবের কাজ থাকে pure ফাংশনে, আর ইনপুট-আউটপুটের কাজ থাকে আলাদা, পাতলা একটি স্তরে।

৫. Prototype রাখুন header-এ

প্রোগ্রাম কয়েকটি ফাইলে ভাগ হলে প্রতিটি ফাইলে আলাদা করে prototype লেখা ঝামেলার, আর একটিতে বদলে অন্যটিতে ভুলে গেলে বাগ। সমাধান: সব prototype একটি header ফাইলে রাখা, আর যে ফাইলের দরকার সে #include করবে।

/* bill.h — the "order slip" other files can see */
double apply_discount(double amount, double percent);
double apply_vat(double amount);
void   print_receipt(double total);

bill.c ফাইলে থাকবে এদের definition, আর main.c শুধু #include "bill.h" লিখে ফাংশনগুলো ব্যবহার করবে। Header হয়ে যায় দুই দলের মাঝের চুক্তিপত্র। এর পূর্ণ কৌশল — include guard, Makefile, library — শিখবেন পর্ব ২৯-এ।

পরীক্ষা: ছোট ফাংশনের সবচেয়ে বড় পুরস্কার

Pure, ছোট ফাংশন পরীক্ষা করা প্রায় মজার কাজ। assert(apply_vat(100.0) == 115.0); জাতীয় এক লাইনের পরীক্ষা লিখে রাখলে, পরে কেউ ভুল করে ফাংশন বদলালে সাথে সাথে ধরা পড়ে। এমন ছোট পরীক্ষাকে বলে unit test. (দশমিক সংখ্যার তুলনায় == ঝুঁকিপূর্ণ — পর্ব ০৫ মনে করুন। যেমন bill.c-এর মতো amount * 1.15 লিখলে 100.0-এর ফল ঠিক 115.0 না হয়ে 114.99999999999999 হয়, তখন এই assert ব্যর্থ হবে। বাস্তবে ছোট একটি সহনসীমা ধরে তুলনা করা হয়।) বিশাল একটি main-এর ক্ষেত্রে এমন পরীক্ষা লেখাই যায় না — সেখানে পুরো প্রোগ্রাম চালিয়ে চোখে দেখা ছাড়া উপায় থাকে না।

৯ · AI-এর যুগে ফাংশন — বিশাল main() থেকে পরিষ্কার নকশা

AI-কে “একটি বিল হিসাবের প্রোগ্রাম লেখো” বললে প্রায়ই পাবেন একটি ৮০-১০০ লাইনের main, যেখানে ইনপুট, হিসাব, যাচাই আর ছাপা — সব একসাথে জড়ানো। প্রোগ্রামটি চলবে। কিন্তু কোনো একটি অংশ বদলাতে বা যাচাই করতে গেলেই আপনি আটকে যাবেন। মনে রাখুন, AI-এর লেখা কোড যাচাইয়ের দায়িত্ব আপনার — আর বিশাল জট পাকানো কোড যাচাই করা প্রায় অসম্ভব।

ফাংশন নিয়ে AI সাধারণত যেসব ভুল করে

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

• প্রতিটি ফাংশন কী করে, এক বাক্যে বলতে পারি — বাক্যে “এবং” নেই
• কোনো global ভ্যারিয়েবল নেই, বা থাকলে তার যুক্তিসঙ্গত কারণ আছে
• প্রতিটি ফাংশনের prototype ব্যবহারের আগে আছে, -Wall -Wextra-এ শূন্য warning
• যে ফাংশন argument “বদলাচ্ছে” বলে মনে হয়, সেখানে pass by value-এর ফাঁদ আছে কি না দেখেছি
• অন্তত একটি হিসাবের ফাংশন আলাদাভাবে ডেকে হাতে হিসাব মিলিয়েছি
• ফাংশনের নাম আর আসল কাজ মিলছে — get_total নামের ফাংশন গোপনে ফাইলে লিখছে না