ফাংশন ও overloading — এক নাম, অনেক কাজ

১ · ফাংশন — নাম দেওয়া, বারবার ব্যবহারযোগ্য একটি প্রতিশ্রুতি

আগের পর্বে আপনি if, switch আর লুপ দিয়ে সিদ্ধান্ত নিতে ও কাজ বারবার করাতে শিখেছেন। কিন্তু ধরুন একটি দোকানের সফটওয়্যারে VAT-সহ দাম হিসাব লাগে বিশ জায়গায়। বিশ জায়গায় একই তিন লাইন কপি করলে কী হয়? হার বদলালে বিশ জায়গায় বদলাতে হয়, একটি ভুলে গেলেই হিসাব গড়বড়। সমাধান — কাজটিকে একবার লিখে একটি নাম দেওয়া, তারপর যেখানে দরকার সেখানে নাম ধরে ডাকা। এই নামওয়ালা কাজের টুকরোর নাম function.

ফাংশনের চারটি অংশ

double bill(double price, int qty) {   // return টাইপ, নাম, parameter-তালিকা
    double sub = price * qty;           // শরীর (body)
    return sub * 1.15;                  // ফল ফেরত
}

double t = bill(500, 2);                // ডাক: 500 আর 2 হলো argument

দুটি শব্দ প্রায়ই গুলিয়ে যায়। সংজ্ঞায় লেখা price আর qty হলো parameter — খালি ঘরের নাম। ডাকার সময় যে আসল মান পাঠান, যেমন 500 আর 2, সেগুলো argument. ফর্মের ঘর “নাম: ______” হলো parameter, আপনি যা লিখে দিলেন তা argument.

Declaration বনাম definition — প্রতিশ্রুতি আর কাজ

C++ compiler ফাইল ওপর থেকে নিচে পড়ে। কোনো নাম ব্যবহারের আগে সে জানতে চায় নামটি কী — কয়টি parameter, কোন টাইপ, কী ফেরত দেয়। তাই ফাংশন দুই ভাগে লেখা যায়:

double bill(double price, int qty);    // declaration: শুধু প্রতিশ্রুতি, শেষে ;

int main() {
    double t = bill(500, 2);            // compiler প্রতিশ্রুতি দেখেই খুশি
}

double bill(double price, int qty) {   // definition: আসল কাজ
    return price * qty * 1.15;
}

প্রথম লাইনটি declaration (একে prototype-ও বলে) — শরীর নেই, শুধু চুক্তি। নিচেরটি definition — চুক্তির সাথে আসল কাজ। একটি ফাংশন যতবার খুশি declare করা যায়, কিন্তু পুরো প্রোগ্রামে definition থাকবে একবারই। Compiler declaration দেখে ডাকটা ঠিক আছে কি না যাচাই করে; definition খুঁজে ডাকের সাথে জোড়া লাগায় linker (পর্ব ০৩-এর “undefined reference” error মনে আছে?)। বড় প্রোগ্রামে declaration থাকে header ফাইলে, definition থাকে .cpp ফাইলে — পর্ব ১১-এ সেটা দেখবেন।

২ · Pass-by-value — ফাংশন পায় একটি ফটোকপি

ফাংশন ডাকলে argument-এর মান সরাসরি ফাংশনে যায় না; যায় তার একটি কপি. Parameter হলো নতুন একটি ভ্যারিয়েবল, যার প্রথম মান argument থেকে কপি করা। একে বলে pass by value, আর C++-এ এটাই ডিফল্ট।

void addGrace(int marks) {
    marks = marks + 5;          // শুধু কপিটা বদলাল
}

int rahim = 38;
addGrace(rahim);
// rahim এখনো 38 — আসল খাতায় কেউ হাত দেয়নি

এটা একই সাথে সুবিধা আর সীমাবদ্ধতা। সুবিধা: ফাংশন ভুল করেও বাইরের ডেটা নষ্ট করতে পারে না, তাই কোড বোঝা সহজ। সীমাবদ্ধতা দুটি — (১) আসল ভ্যারিয়েবল বদলানো যায় না, (২) বড় জিনিস (যেমন লাখ অক্ষরের একটি std::string) প্রতিবার কপি হলে সময় আর মেমরি খরচ হয়। int বা double-এর মতো ছোট টাইপে কপির খরচ নগণ্য, তাই এগুলো by value পাঠানোই স্বাভাবিক।

৩ · Call stack — প্রতিটি ডাকের নিজের খাতা

একটি ফাংশন আরেকটি ফাংশনকে ডাকতে পারে, সেটি আবার আরেকটিকে। কম্পিউটার কীভাবে মনে রাখে কে কাকে ডেকেছে, আর কাজ শেষে কোথায় ফিরতে হবে? উত্তর: call stack. প্রতিটি ডাকের জন্য মেমরিতে একটি নতুন খাতা খোলে — একে বলে stack frame. এতে থাকে সেই ডাকের parameter, তার local variable আর কাজ শেষে কোথায় ফিরতে হবে সেই ঠিকানা। নতুন ডাক মানে আগের খাতার ওপর নতুন খাতা; return মানে ওপরের খাতাটি সরিয়ে ফেলা।

নিচে main ডাকছে bill-কে, আর bill ডাকছে vat-কে। প্রতিটি ধাপে stack-এ কী আছে, দেখুন:

1double vat(double amount) {2    return amount * 0.15;3}4double bill(double price, int qty) {5    double sub = price * qty;6    return sub + vat(sub);7}8int main() {9    double t = bill(500, 2);10}

Scope আর lifetime — কে কোথায় দেখা যায়, কতক্ষণ বাঁচে

উপরের ধাপগুলো থেকে দুটি আলাদা ধারণা বেরিয়ে আসে। Scope হলো কোডের কোন অংশ থেকে একটি নাম দেখা যায় — sub শুধু bill-এর { }-এর ভেতরে। Lifetime হলো কতক্ষণ জিনিসটি মেমরিতে বেঁচে থাকে — local ভ্যারিয়েবল জন্মায় ডাকের সাথে, মরে return-এর সাথে। এ কারণেই দুটি ভিন্ন ফাংশনে একই নাম sub রাখলে কোনো সংঘর্ষ হয় না: দুটি আলাদা খাতা, আলাদা ঘর।

Global, static local আর ব্লকের ভেতরের ভ্যারিয়েবলের scope ও lifetime-এর পূর্ণ নিয়ম C কোর্সের স্কোপ ও স্টোরেজ ক্লাস পর্বে বিস্তারিত আছে; C++-এ নিয়মগুলো একই। শুধু মনে রাখুন: ফাংশনের যা দরকার, তা parameter দিয়ে নিন; যা দেওয়ার, তা return দিয়ে দিন — global ভ্যারিয়েবলের মাধ্যমে লুকিয়ে ডেটা আদান-প্রদান নয়।

৪ · Default argument — না বললে যা ধরে নেওয়া হবে

বেশিরভাগ বিক্রিতে পণ্য একটি, আর VAT ১৫%. প্রতিবার bill(200, 1, 0.15) লেখা বিরক্তিকর। C++ আপনাকে parameter-এর জন্য আগে থেকে একটি মান ঠিক করে দিতে দেয় — ডাকার সময় argument না দিলে সেটাই বসবে। একে বলে default argument.

কিন্তু নিয়ম আছে, আর নিয়মগুলো আসে একটি সহজ সীমাবদ্ধতা থেকে: compiler argument-গুলো বাম থেকে ডানে মেলায়। ধাপে ধাপে দেখুন compiler কীভাবে খালি ঘর ভরায়:

1double bill(double price, int qty = 1, double vatRate = 0.15);2bill(200);3bill(200, 3);4bill(200, 3, 0.0);5bill(200, , 0.05);6double bad(double price = 100, int qty);

Default কোথায় লিখবেন — একবার, declaration-এ

Default মান ব্যবহার হয় ডাকার জায়গায় — compiler ডাকটা compile করার সময় ফাঁকা ঘর ভরে দেয়। তাই ডাকার জায়গা থেকে যা দেখা যায়, অর্থাৎ declaration-এ, default লিখতে হয়। একই default declaration আর definition দুই জায়গায় লিখলে compiler “default argument given for parameter … redefinition” ধরনের error দেয়। প্রচলিত রীতি: header-এর declaration-এ default, .cpp-এর definition-এ নয় (সেখানে চাইলে comment-এ লিখে রাখুন: int qty /* = 1 */)।

৫ · Function overloading — এক নাম, ভিন্ন parameter-তালিকা

বৃত্তের ক্ষেত্রফল আর আয়তক্ষেত্রের ক্ষেত্রফল — দুটোই “ক্ষেত্রফল।” C-তে দুটির আলাদা নাম রাখতে হতো: area_circle, area_rect. C++-এ দুটিরই নাম রাখা যায় area, যদি তাদের parameter-তালিকা আলাদা হয়। একে বলে function overloading.

Overload আলাদা হতে পারে parameter-এর সংখ্যায় (area(r) বনাম area(w, h)) বা টাইপে (maxOf(int, int) বনাম maxOf(double, double)). নাম আর parameter-টাইপের এই তালিকাকে বলে function signature. নিচের কোডটি চালিয়ে দেখুন:

#include <print>
#include <string>

double area(double r) { return 3.14159 * r * r; }     // circle
double area(double w, double h) { return w * h; }     // rectangle

int maxOf(int a, int b) { return a > b ? a : b; }
double maxOf(double a, double b) { return a > b ? a : b; }
std::string maxOf(std::string a, std::string b) { return a > b ? a : b; }

int main() {
    std::println("circle r=2      : {:.2f}", area(2.0));
    std::println("rectangle 3x4   : {}", area(3.0, 4.0));
    std::println("maxOf(7, 3)     : {}", maxOf(7, 3));
    std::println("maxOf(2.5, 9.1) : {}", maxOf(2.5, 9.1));
    std::println("maxOf(names)    : {}", maxOf("Rahim", "Karim"));
}

শুধু return টাইপ আলাদা হলে overload হয় না

int    parse(std::string s);
double parse(std::string s);   // error: ambiguating new declaration

কেন? কারণ ডাকার সময় return টাইপ প্রায়ই দেখা যায় না। parse("42"); — ফল কোথাও রাখা হয়নি, তাহলে কোনটা ডাকবে? auto x = parse("42"); — auto তো নিজেই ফল দেখে টাইপ ঠিক করতে চায়! Compiler argument দেখে বাছাই করে, ফল কোথায় যাবে তা দেখে নয়। তাই overload আলাদা হতে হবে parameter-তালিকায়। আলাদা ফল চাইলে আলাদা নাম দিন: parseInt, parseDouble.

৬ · Compiler কোনটা বেছে নেয় — overload resolution

Argument-এর টাইপ সবসময় কোনো overload-এর সাথে হুবহু মেলে না। print('A') ডাকলে, অথচ শুধু print(int) আর print(double) থাকলে, কোনটা চলবে? Compiler-এর এই বাছাই প্রক্রিয়ার নাম overload resolution. পূর্ণ নিয়ম standard-এর অনেক পৃষ্ঠা জুড়ে, কিন্তু মূল ধারণা একটি সিঁড়ি:

Compiler প্রতিটি overload-এর জন্য দেখে, argument থেকে parameter-এ যেতে কোন ধাপ লাগে। যার ধাপ সবচেয়ে ওপরে, সে জেতে। দুজন সমান ধাপে থাকলে কেউ জেতে না — compile error. তিনটি overload নিয়ে ছয়টি ডাক ধাপে ধাপে দেখুন, প্রতিবার আগে নিজে অনুমান করুন:

1void print(int x);2void print(double x);3void print(std::string s);4print(42);5print(3.14);6print('A');7print(2.5f);8print("Dhaka");9print(10L);10print(static_cast<int>(10L));

Overloading আর default argument একসাথে — টাইয়ের আরেক উৎস

void show(int x);
void show(int x, int width = 0);

show(5);       // error: call of overloaded 'show(int)' is ambiguous

দুটি declaration আলাদাভাবে বৈধ, কিন্তু show(5) দুটির সাথেই exact match — দ্বিতীয়টির ফাঁকা ঘর তো default দিয়ে ভরে যায়। মজার ব্যাপার, error আসে ডাকার জায়গায়, declaration-এ নয়; তাই অনেক দিন কেউ show(5) না ডাকলে সমস্যাটা লুকিয়েই থাকে। নিয়ম: একই কাজের জন্য হয় overload, নয় default argument — দুটো মিশিয়ে নয়।

৭ · Recursion — নিজেকেই ডাকা

একটি ফাংশন নিজেকেও ডাকতে পারে — একে বলে recursion. শর্ত দুটি: (১) প্রতিটি ডাকে সমস্যা একটু ছোট হবে, (২) একটি সবচেয়ে ছোট অবস্থা থাকবে, যেখানে আর না ডেকে সরাসরি উত্তর দেওয়া যায় — একে বলে base case. ক্লাসিক উদাহরণ factorial: ৪! = ৪ × ৩!, আর ১! = ১.

long long factorial(int n) {
    if (n <= 1) return 1;              // base case
    return n * factorial(n - 1);       // ছোট সমস্যা নিজেকে দিয়ে
}

অংশ ৩-এর call stack-ই এখানে আসল চাবি। প্রতিটি ডাক নিজের frame পায়, নিজের n পায় — তাই চারটি ভিন্ন n একসাথে বেঁচে থাকতে পারে:

1long long factorial(int n) {2    if (n <= 1) return 1;3    return n * factorial(n - 1);4}

Fibonacci-র recursion (fib(n) = fib(n-1) + fib(n-2)) দেখতে আরও সুন্দর, কিন্তু একই মান বারবার হিসাব করে — fib(40)-এ ফাংশন-ডাক দাঁড়ায় কোটির ঘরে। লুপ বা আগের ফল মনে রাখার কৌশল (memoization) দিয়ে সেটা চোখের পলকে হয়। Recursion কখন ভালো আর কখন লুপ ভালো, tail call আর গভীর recursion-এর বিপদ — এসব C কোর্সের রিকার্শন — নিজেকেই ডাকা পর্বে বিস্তারিত।

৮ · আধুনিক ফাংশন-লেখা — auto, nodiscard, inline, constexpr

auto return আর trailing return

পর্ব ০৫-এ ভ্যারিয়েবলের জন্য auto দেখেছেন। C++14 থেকে ফাংশনের return টাইপেও auto লেখা যায় — compiler return-এর মান দেখে টাইপ ঠিক করে। একে বলে return type deduction. আর C++11 থেকে return টাইপ নামের পরে, -> দিয়েও লেখা যায় — trailing return type:

auto square(int x) { return x * x; }          // compiler ঠিক করে: int
auto area(double r) -> double {               // trailing: টাইপ নামের পরে
    return 3.14159 * r * r;
}
auto pick(bool b) { if (b) return 1; return 2.5; }  // error: int আর double দুই রকম

শেষ লাইনটি খেয়াল করুন: সব return-কে একই টাইপ দিতে হবে, নইলে compiler সিদ্ধান্ত নিতে পারে না। ছোট, স্পষ্ট ফাংশনে auto return চলে; কিন্তু অন্যের ব্যবহারের জন্য লেখা ফাংশনে (বিশেষ করে header-এ) টাইপটা লিখে দিন, কারণ declaration-ই চুক্তি — চুক্তিতে “যা হয় হবে” লেখা ভালো নয়। Trailing return-এর আসল কাজ template-এ, যেখানে return টাইপ parameter-এর টাইপের ওপর নির্ভর করে (যেমন -> decltype(a + b); template শিখবেন পর্ব ২৮-এ); আর lambda-য় (পর্ব ৩৪) এটাই একমাত্র লেখার উপায়।

[[nodiscard]] — “আমার ফল ফেলে দেবেন না”

কিছু ফাংশনের ফল উপেক্ষা করা প্রায় নিশ্চিত বাগ। bill(200); লিখে ফল কোথাও রাখলেন না — হিসাবটা হলো, তারপর হাওয়ায় মিলিয়ে গেল। C++17-এর attribute [[nodiscard]] দিয়ে চিহ্নিত করলে compiler সতর্ক করে দেয়:

C++20 থেকে কারণও লিখে দেওয়া যায়: [[nodiscard("হিসাবের ফল ব্যবহার করুন")]]. Standard library নিজেও এটা ব্যবহার করে — C++20 থেকে v.empty() (“খালি কি না?” প্রশ্ন) [[nodiscard]], কারণ অনেকে ভুল করে একে “খালি করো” ভেবে ফল ছাড়াই লিখতেন।

inline — আজকের আসল অর্থ

নাম দেখে মনে হয় inline মানে “ফাংশন ডাকার বদলে কোডটা সেখানে বসিয়ে দাও, দ্রুত হবে।” ১৯৮০-৯০-এর দশকে এটাই উদ্দেশ্য ছিল। কিন্তু আজকের compiler এই সিদ্ধান্ত নিজেই নেয় — -O2 দিলে ছোট ফাংশন inline না লিখলেও বসিয়ে দেয় (optimization), আর বড় ফাংশনে inline লিখলেও প্রায়ই বসায় না। তাহলে শব্দটি এখন কী কাজে লাগে?

উত্তর: ODR (One Definition Rule). সাধারণ নিয়মে একটি ফাংশনের definition পুরো প্রোগ্রামে একবারই থাকতে পারে। কিন্তু header ফাইলে definition লিখে সেই header দুটি .cpp ফাইলে #include করলে definition দুবার হয়ে যায় — linker বলে “multiple definition.” inline function এই নিয়মে ছাড় পায়: প্রতিটি ফাইলে থাকতে পারে, যদি সব কপি হুবহু এক হয়। অর্থাৎ আধুনিক C++-এ inline মানে “এই definition header-এ থাকতে পারে”, গতির প্রতিশ্রুতি নয়। Class-এর ভেতরে লেখা member ফাংশন আর constexpr ফাংশন নিজে থেকেই inline. পর্ব ১১-এ header লেখার সময় এটা কাজে লাগবে।

constexpr ফাংশন — এক ঝলক

পর্ব ০৫-এ constexpr ভ্যারিয়েবল দেখেছেন। ফাংশনও constexpr হতে পারে: constexpr int square(int x) { return x * x; }. তখন argument compile-এর সময় জানা থাকলে compiler নিজেই ফল হিসাব করে প্রোগ্রামে বসিয়ে দেয় — চলার সময় কোনো খরচ নেই। আর argument চলার সময় এলে সাধারণ ফাংশনের মতোই চলে। পর্ব ৩৯-এ এর পূর্ণ শক্তি দেখবেন।

এবার সব একসাথে — declaration-এ default আর [[nodiscard]], main-এর পরে definition, আর একটি recursive ফাংশন:

#include <print>

// declaration: default argument shudhu ekhane
[[nodiscard]] double bill(double price, int qty = 1, double vatRate = 0.15);
[[nodiscard]] long long factorial(int n);

int main() {
    std::println("1 item      : {:.2f}", bill(200.0));
    std::println("3 items     : {:.2f}", bill(200.0, 3));
    std::println("3 items, 0% : {:.2f}", bill(200.0, 3, 0.0));
    std::println("10!         : {}", factorial(10));
}

double bill(double price, int qty, double vatRate) {   // default abar noy
    return price * qty * (1.0 + vatRate);
}

long long factorial(int n) {
    if (n <= 1) return 1;                              // base case
    return n * factorial(n - 1);
}

৯ · AI-এর যুগে — ফাংশনের চুক্তি যাচাই করা আপনার কাজ

AI টুল ফাংশন লেখে চমৎকার গতিতে, আর বেশিরভাগ সময় সেগুলো compile-ও হয়। সমস্যা হলো ফাংশনের ভুল প্রায়ই চুক্তিতে — কোন overload কখন বাছাই হবে, default কী ধরে নিচ্ছে, ফেরত দেওয়া জিনিস আদৌ বেঁচে আছে কি না। এগুলো চোখে না পড়লে ধরা পড়ে অনেক পরে, অন্য কারও কোডে। AI-এর লেখা C++ ফাংশনে বারবার দেখা যায়:

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

• প্রতিটি ফাংশনের নাম তার একটিমাত্র কাজ বলে দেয়, আর declaration দেখেই বুঝি কীভাবে ডাকতে হবে
• প্রতিটি overload-ডাকের জন্য নিজে বলতে পারি কোনটা চলবে; char, float, long argument দিয়ে মনে মনে পরীক্ষা করেছি
• Default argument শুধু ডান দিকে, শুধু declaration-এ, আর একই নামের overload-এর সাথে সংঘর্ষ নেই
• কোনো ফাংশন local ভ্যারিয়েবলের reference বা ঠিকানা ফেরত দিচ্ছে না
• গুরুত্বপূর্ণ ফল দেওয়া ফাংশনে [[nodiscard]] আছে, আর কোথাও ফল উপেক্ষা করা হয়নি
• প্রতিটি recursive ফাংশনে base case আছে, আর প্রতিটি ডাকে সমস্যা সত্যিই ছোট হচ্ছে