সরাসরি পর্বে যান
পর্ব ২৯ · ৮৬-এর মধ্যে · মডিউল ৫

Parameter passing — by value, by reference, by sharing আর by name

Parameter Passing — By Value, By Reference, By Sharing and By Name

Taught in Bangla, this lesson separates the in, out and in-out models from implementations such as copying values, passing addresses, copying back and passing expressions. It traces one program under four modes, where g ends as 20, 60, 6 and 60, checked by an in-page Python simulator. A real Clang 22.1.8 run shows swap_add(p, p) zeroing the value, and it covers copy-back order, call by sharing, const reference and move costs, default, keyword and variadic arguments, and Haat's value-only parameters.

এই পর্বে যা শিখবেন

  • Formal আর actual parameter আলাদা করা, আর in, out, in-out মডেলের সঙ্গে পাঁচটি বাস্তবায়ন মডেল environment ও store-এর নিয়মে লেখা
  • একই program value, reference, value-result আর name-এ হাতে trace করে আউটপুট বের করা, আর একটি ছোট interpreter দিয়ে মেলানো
  • Aliasing কীভাবে swap, a[i] আর copy back-এর ক্রমে ফাঁদ তৈরি করে, আর ভাষাগুলো কীভাবে তা আটকায়
  • Call by sharing, copy-এর খরচ, const reference আর move সত্যিকারের Clang আর Python run দেখে ব্যাখ্যা করা
  • Default, keyword আর variadic argument-এর নকশা আর Haat-এ by-reference-এর বিকল্প বুঝে বানানো

১ · Argument কীভাবে পৌঁছায় — formal, actual আর তিন দিক

বাজারঘরের দর্জি-বিভাগে গ্রাহক জামার মাপ দিতে পারেন তিনভাবে। এক, মাপের খাতার ফটোকপি দেওয়া: দর্জি কপিতে যত দাগই কাটুন, গ্রাহকের খাতা অক্ষত। দুই, আসল খাতাটিই দিয়ে আসা: দর্জি যা লেখেন, গ্রাহক বাড়ি ফিরে খাতায় তা-ই দেখেন। তিন, ফটোকপি দিয়ে বলা, “কাজ শেষে কপির শেষ অবস্থাটা আমার খাতায় তুলে দেবেন”: মাঝখানে খাতা বদলায় না, শেষে একবারে বদলায়। আর একটি চতুর্থ পথও আছে: মাপ না দিয়ে বলা, “যখন দরকার, আমার বাসায় এসে মেপে নেবেন”. এই চারটি পথই এই পর্বের চার প্রধান parameter passing পদ্ধতি: by value, by reference, by value-result আর by name.

শুরুতে দুটি শব্দ। Function-এর সংজ্ঞায় যে নাম লেখা থাকে, যেমন fn price(qty: Int, unit: Int)-এর qty, তাকে বলে formal parameter. ডাকার জায়গায় যা লেখা হয়, যেমন price(2, 520)-এর 2, তা actual parameter বা argument. Parameter passing-এর পুরো প্রশ্নটি এক বাক্যে: call-এর সময় actual থেকে formal-এ কী যায়, আর ফেরার সময় কিছু ফেরত আসে কি না।

প্রশ্নটির দুটি স্তর আছে, আর পরীক্ষায় দুটি প্রায়ই গুলিয়ে যায়। প্রথম স্তর হলো parameter mode, অর্থাৎ তথ্য কোন দিকে যায়। Robert Sebesta-র Concepts of Programming Languages-এর মতো বহু পাঠ্যবই একে তিন ভাগে ভাগ করে:

সংজ্ঞা ২৯.১ — তিন semantic model

In mode: তথ্য শুধু ডাকা-পক্ষ (caller) থেকে function-এ (callee) যায়। Function parameter পড়ে, কিন্তু তার মাধ্যমে ডাকা-পক্ষকে কিছু জানায় না।

Out mode: তথ্য শুধু function থেকে ডাকা-পক্ষে আসে। শুরুতে parameter-এ কোনো অর্থপূর্ণ মান থাকে না; function সেখানে ফল লিখে দেয়।

In-out mode: দুই দিকেই। Function মান পড়ে, বদলায়, আর বদলটি ডাকা-পক্ষ দেখে।

দ্বিতীয় স্তর হলো বাস্তবায়ন মডেল: সেই দিকটি যন্ত্রে কীভাবে ঘটানো হয়। মান কপি করে, ঘরের ঠিকানা পাঠিয়ে, ফেরার সময় কপি করে, নাকি expression-টিই পাঠিয়ে। একই in-out mode দুইভাবে বাস্তবায়ন করা যায় (reference বা value-result), আর অংশ ৫-এ দেখবেন aliasing থাকলে তাদের ফল আলাদা হয়। এজন্য Ada-র মতো কিছু ভাষা প্রোগ্রামারকে শুধু mode লিখতে বলে (in, out, in out) আর বাস্তবায়ন অনেক ক্ষেত্রে compiler-এর হাতে ছাড়ে।

Haat v1 এখানে সবচেয়ে সরল পথ নিয়েছে: সব parameter in mode, by value. তার ওপর reference বাস্তবায়নের নকশা-সিদ্ধান্ত ১৯ বলে parameter অপরিবর্তনীয়, ঠিক let-এর মতো। সত্যিকারের run:

fn bump(n: Int) -> Int {
    n = n + 1;
    return n;
}
print(bump(5));
~/haat $ python haat.py check bump.haat
2:5: error: cannot assign to parameter 'n'

C বা Python-এ এই কোড চলত, আর ফল হতো 6; ডাকা-পক্ষের কিছুই বদলাত না, কারণ n একটি কপি। Haat বলছে, “কপিতে লিখে কী লাভ? সম্ভবত আপনি ভেবেছেন ডাকা-পক্ষ বদলাবে।” এটি একটি নকশা-পছন্দ: Rust-এও parameter ডিফল্টে অপরিবর্তনীয় (mut n: i32 লিখলে তবে বদলানো যায়), আর Ada-র in parameter-এ লেখা compile error. দরকার হলে Haat-এ লিখুন let m = n + 1;.

২ · পাঁচ বাস্তবায়ন মডেল — ছবিতে আর নিয়মে

পাঁচটি মডেল এক ছবিতে দেখুন। প্রতিটি সারিতে বাঁয়ে ডাকা-পক্ষের variable a, ডানে function-এর parameter x, আর তীর দেখায় কখন কী সরে।

ছবি ২৯.১ — Parameter passing-এর পাঁচ বাস্তবায়ন মডেল

বাঁয়ে caller-এর ঘর, ডানে callee-র parameter. ষষ্ঠ মডেল by name পর্ব ১৯-এ।

Five implementation models of parameter passing: value, result, value-result, reference and sharing ১. by value · in a = 2 x = 2 ঢোকার সময় কপি ২. by result · out a x = ? ফেরার সময় কপি ৩. by value-result · in-out a = 2 x = 2 ঢোকার সময় ফেরার সময় ৪. by reference · in-out a = 2 x একই ঘর, দ্বিতীয় নাম ৫. by sharing · object a ● ● x object [chal, dal]
ছবি ২৯.১ — প্রথম তিনটি মডেল কপি দিয়ে চলে, তাই callee-র নিজের ঘর আছে। চতুর্থটিতে callee শুধু ঠিকানা পায়: x আর a একে অপরের alias. পঞ্চমটিতে কপি হয় তীরটি (reference-এর মান), তাই object ভাগ হয়, কিন্তু x-কে নতুন object-এ সরালে a অক্ষত থাকে।

এবার মডেলগুলো একটু নিখুঁত করে লিখি। পর্ব ২৩-এর (Pointer আর reference) ভাষায় environment ρ নাম থেকে ঘর (location ℓ) দেয়, আর store σ ঘর থেকে মান। ρf হলো f যেখানে সংজ্ঞায়িত হয়েছে সেখানকার environment (static scoping, পর্ব ১৫). a ⇓ v মানে “a হিসাব করলে মান v”, আর a ⇓L ℓ মানে “a-কে l-value হিসেবে হিসাব করলে ঘর ℓ” (a যেমন g বা a[i]). শেষে “দেহ ⇓ σ′” মানে দেহ চালানোর পরের store σ′. দাগের ওপরের শর্ত সত্য হলে নিচের সিদ্ধান্ত সত্য:

ρ, σ ⊢ a ⇓ v    ℓ′ নতুন ঘর    ρf[x ↦ ℓ′], σ[ℓ′ ↦ v] ⊢ দেহ ⇓ σ′
ρ, σ ⊢ f(a) ⇓ σ′
(Call-V)
ρ ⊢ a ⇓L ℓ    ρf[x ↦ ℓ], σ ⊢ দেহ ⇓ σ′
ρ, σ ⊢ f(a) ⇓ σ′
(Call-R)
ρ ⊢ a ⇓L ℓ    ℓ′ নতুন ঘর    ρf[x ↦ ℓ′], σ[ℓ′ ↦ σ(ℓ)] ⊢ দেহ ⇓ σ′
ρ, σ ⊢ f(a) ⇓ σ′[ℓ ↦ σ′(ℓ′)]
(Call-VR)

তিনটি নিয়মের পার্থক্য পড়ে নিন। Call-V একটি নতুন ঘর ℓ′ বানায় আর তাতে মানটি রাখে; x আর a-র কোনো যোগ নেই। Call-R কোনো নতুন ঘর বানায় না: x-কে সরাসরি a-র ঘর ℓ-এ বাঁধে, তাই দেহের প্রতিটি লেখা সঙ্গে সঙ্গে a-তে পড়ে। Call-VR নতুন ঘরে কপি নেয়, দেহ চালায়, আর শেষে (নিচের লাইনের σ′[ℓ ↦ σ′(ℓ′)]) x-এর শেষ মান a-র ঘরে লিখে দেয়। লক্ষ করুন, ℓ ঠিক হয়েছে call-এর সময়ে, ফেরার সময়ে নয়; অংশ ৩-এ দেখবেন a[i]-এর বেলায় এই খুঁটিনাটিই উত্তর ঠিক করে। Call by result-এর নিয়ম Call-VR-এর মতোই, শুধু ℓ′-এ প্রথমে কোনো মান বসে না। আর call by name-এ x-এর সঙ্গে বাঁধা হয় একটি thunk: expression a আর ডাকা-পক্ষের ρ একসঙ্গে, যা প্রতিবার ব্যবহারে নতুন করে হিসাব হয়। এর পুরো আলোচনা, Jensen's device-সহ, পর্ব ১৯-এ (Evaluation strategy); এখানে শুধু তুলনার জন্য আসবে।

ভাষাডিফল্টঅন্য পথ
Cby valuePointer পাঠিয়ে হাতে বানানো by reference
C++by valueT& (reference), const T&, T&& (move)
Javaby value (primitive আর reference দুটিরই মান)নেই; object-এর বেলায় ফল sharing
Python, JavaScriptby sharingনেই
Pascal (১৯৭০)by valuevar parameter = by reference
Adainout, in out; ছোট scalar type কপি দিয়ে, কিছু type reference দিয়ে, বাকিগুলো compiler বেছে নেয়
C#by valueref, out, in (শুধু-পড়ার reference)
Swiftby valueinout: সংজ্ঞায় copy-in copy-out, বাস্তবায়নে প্রায়ই reference
ALGOL 60by namevalue ঘোষণা করলে by value
Haat v1by value, parameter অপরিবর্তনীয়নেই; closure দিয়ে অনুকরণ (অংশ ৯)

৩ · একই program, চার mode — পরীক্ষার ক্লাসিক trace

বিশ্ববিদ্যালয় আর চাকরির লিখিত পরীক্ষায় parameter passing-এর সবচেয়ে প্রচলিত প্রশ্ন: “একটি program দেওয়া আছে; call by value, reference, value-result আর name-এ আউটপুট কী?” নিচের program Haat-এর মতো করে লেখা, তবে parameter-এর আগে MODE জায়গাটিতে চারটি mode বসিয়ে দেখা হবে (এটি Haat-এর বর্ধিত রূপ: v1-এ শুধু by value, আর parameter-এ লেখাও নিষেধ)। ধাপে ধাপে দেখুন:

1var g = 2;2fn f(MODE x: Int) {3    x = x + 1;4    g = g * 10;5    x = x * 2;6}7f(g);8print(g);
এই ধাপের পরে
value
reference
value-result
name
  1. Call. By value: x একটি নতুন ঘর, তাতে 2. By reference: x-এর নিজের ঘর নেই, x আর g একই ঘর (x≡g). By value-result: নতুন ঘরে 2, আর g-এর ঠিকানাটি মনে রাখা হলো। By name: x পায় thunk⟨g⟩, অর্থাৎ “দরকার হলে ডাকা-পক্ষের g”.
  2. x = x + 1. By value আর value-result-এ শুধু x বদলায়: 3, g তখনো 2. By reference-এ লেখাটি সরাসরি g-তে: g = 3. By name-এ thunk খুলে পাওয়া ঘরটিও g, তাই g = 3.
  3. g = g * 10. এবার function সরাসরি global g বদলায়। By value আর value-result-এ g = 2 × 10 = 20. বাকি দুটিতে g আগেই 3 ছিল: 30.
  4. x = x * 2. By value আর value-result-এ x = 3 × 2 = 6, g অক্ষত 20. By reference আর by name-এ x মানে g: 30 × 2 = 60.
  5. ফেরা। By value-তে x-এর ঘর হারিয়ে যায়, g = 20 থাকে। By value-result-এ এখন copy back: মনে রাখা ঠিকানায় (g) x-এর শেষ মান 6 লেখা হয়, ফলে function-এর ভেতরের g = g * 10 মুছে গেল! বাকি দুটিতে কিছু করার নেই: g = 60.
  6. আউটপুট। চার mode, তিনটি আলাদা উত্তর: 20, 60, 6, 60. পার্থক্যের মূল কারণ একটিই: function-এর ভেতরে x আর g একই জিনিসের দুটি পথ (aliasing). এই program-এ name আর reference এক উত্তর দিল, কারণ actual parameter একটি সাধারণ variable; a[i] হলে তারাও আলাদা হবে।

হাতে trace করা ভুল হতে পারে, তাই এবার একটি ছোট interpreter দিয়ে মেলাই। নিচের Python কোডে environment আর store আলাদা (ঠিক নিয়ম Call-V, Call-R আর Call-VR-এর মতো)। প্রতিটি mode-এর জন্য call-এর সময় x কীভাবে বাঁধা হয়, তা মাত্র চার লাইনে: new(...) মানে নতুন ঘরে কপি, loc(arg, env) মানে ডাকা-পক্ষের ঘরটিই, আর thunk মানে expression আর ডাকা-পক্ষের environment একসঙ্গে। Program দুটি: উপরের f(g), আর একটি array-ওয়ালা p(a[i]), যার দেহ i = i + 1; x = x + 5; a[0] = a[0] * 10;, শুরুতে i = 0 আর a = [10, 20].

# env: name -> location (array -> list of locations); store: location -> value
def run(mode, globs, arg, body):
    store, env = [], {}
    def new(v): store.append(v); return len(store) - 1
    for name, v in globs.items():
        env[name] = [new(x) for x in v] if isinstance(v, list) else new(v)
    def loc(e, en):                       # l-value -> location
        if e[0] == "idx": return en[e[1]][val(e[2], en)]
        b = en[e[1]]
        return loc(b[1], b[2]) if isinstance(b, tuple) else b  # by name: redo
    def val(e, en):
        if e[0] == "num": return e[1]
        if e[0] == "+": return val(e[1], en) + val(e[2], en)
        if e[0] == "*": return val(e[1], en) * val(e[2], en)
        return store[loc(e, en)]
    local = dict(env)                     # callee also sees the globals
    if mode in ("value", "value-result"): local["x"] = new(val(arg, env))  # copy in
    if mode == "value-result": back = loc(arg, env)       # address fixed at call
    if mode == "reference": local["x"] = loc(arg, env)    # caller's own box
    if mode == "name": local["x"] = ("thunk", arg, env)   # expression + caller env
    for target, e in body:                # each statement is: target = e
        store[loc(target, local)] = val(e, local)
    if mode == "value-result": store[back] = store[local["x"]]         # copy out
    return {n: [store[l] for l in L] if isinstance(L, list) else store[L]
            for n, L in env.items()}

V, N = (lambda n: ("var", n)), (lambda k: ("num", k))
A0 = ("idx", "a", N(0))
progs = {"f(g)": ({"g": 2}, V("g"), [(V("x"), ("+", V("x"), N(1))),
                  (V("g"), ("*", V("g"), N(10))), (V("x"), ("*", V("x"), N(2)))]),
         "p(a[i])": ({"i": 0, "a": [10, 20]}, ("idx", "a", V("i")), [(V("i"),
                  ("+", V("i"), N(1))), (V("x"), ("+", V("x"), N(5))), (A0, ("*", A0, N(10)))])}
for title, prog in progs.items():
    for mode in ["value", "reference", "value-result", "name"]:
        print(f"{title:8} {mode:13}", run(mode, *prog))

আসল আউটপুট (Pyodide-এ, আর লেখকের যন্ত্রে CPython 3.14.4-এ হুবহু এক):

f(g)     value         {'g': 20}
f(g)     reference     {'g': 60}
f(g)     value-result  {'g': 6}
f(g)     name          {'g': 60}
p(a[i])  value         {'i': 1, 'a': [100, 20]}
p(a[i])  reference     {'i': 1, 'a': [150, 20]}
p(a[i])  value-result  {'i': 1, 'a': [15, 20]}
p(a[i])  name          {'i': 1, 'a': [100, 25]}

প্রথম চার লাইন stepper-এর সঙ্গে মিলে গেল। পরের চার লাইনে চারটিই আলাদা। By value: x একটি কপি, শুধু a[0] * 10 কাজ করে, [100, 20]. By reference: call-এর সময় i = 0, তাই x চিরকালের জন্য a[0]-এর ঘর; 10 + 5 = 15, তারপর × 10 = 150. By value-result: x = 10 → 15, এর মধ্যে a[0] = 100 হয়েছিল, কিন্তু ফেরার সময় call-এর সময়ে মনে রাখা ঠিকানা a[0]-এ 15 লেখা হয়ে সেটি মুছে যায়: [15, 20]. By name: x প্রতিবার a[i] নতুন করে হিসাব করে, আর তখন i = 1, তাই লেখা হয় a[1]-এ: 20 + 5 = 25, আর a[0] = 100. লক্ষ করুন, এখানে by name আর by reference প্রথমবার আলাদা হলো, কারণ i বদলেছে। এই interpreter-এর loc function-টিই পুরো পার্থক্য তৈরি করে: কোন mode-এ ঠিকানা কখন আর কোন environment-এ হিসাব হয়।

পরীক্ষায় সাবধান: value-result-এর প্রশ্নে লিখে দিন আপনি ঠিকানা কখন নিয়েছেন। ফেরার সময়ে ঠিকানা নিলে p(a[i])-এর উত্তর হয় [100, 15] (লেখকের যন্ত্রে একই interpreter-এর একটি রূপ চালিয়ে মেলানো), কারণ তখন i = 1. বেশিরভাগ পাঠ্যবই আর বাস্তব ভাষা call-এর সময়ের ঠিকানা ধরে, কিন্তু প্রশ্নে না বললে ধরে নেওয়া অনুমানটি উত্তরে লিখে রাখাই নিরাপদ।

৪ · Call by reference আর aliasing — swap-এর ফাঁদ

Call by reference-এ callee ডাকা-পক্ষের ঘরের ঠিকানা পায়। কপির খরচ নেই, আর in-out কাজ (দুটি মান অদলবদল, একাধিক ফল ফেরত) সহজ। C-তে ভাষার স্তরে reference নেই, তাই প্রোগ্রামার নিজে ঠিকানা পাঠান (&total) আর ভেতরে *p লেখেন; C++ reference সেই কাজটি compiler-কে দেয়। সত্যিকারের run, একই কাজ তিনভাবে:

#include <cstdio>

void by_value(int x)      { x = x + 60; }        // gets a copy
void by_pointer(int *p)   { *p = *p + 60; }      // C style: pass the address
void by_ref(int &x)       { x = x + 60; }        // C++: x is another name

void swap_tmp(int &x, int &y) { int t = x; x = y; y = t; }
void swap_add(int &x, int &y) { x = x + y; y = x - y; x = x - y; }

int main() {
    int total = 936;
    by_value(total);   std::printf("by value:   %d\n", total);
    by_pointer(&total); std::printf("by pointer: %d\n", total);
    by_ref(total);     std::printf("by ref:     %d\n", total);

    int p = 5, q = 8;
    swap_add(p, q);    std::printf("swap_add(p, q): p=%d q=%d\n", p, q);
    swap_tmp(p, p);    std::printf("swap_tmp(p, p): p=%d\n", p);
    swap_add(p, p);    std::printf("swap_add(p, p): p=%d\n", p);
    return 0;
}
~/haat $ zig c++ -std=c++20 -Wall -Wextra modes.cpp -o modes.exe && ./modes.exe
by value:   936
by pointer: 996
by ref:     1056
swap_add(p, q): p=8 q=5
swap_tmp(p, p): p=8
swap_add(p, p): p=0

সত্যিকারের run: PyPI-র ziglang 0.17.1 (MIT licence), যার ভেতরে Clang 22.1.8; এখানে zig মানে python -m ziglang. Wandbox এই সময়ে HTTP 500 দিচ্ছিল, তাই C++ কোড পাতায় চালানোর ব্লক হিসেবে রাখা হয়নি। প্রথম তিন লাইন: by value কপিতে 60 যোগ করে, total 936-ই থাকে; pointer আর reference দুটিই আসল ঘরে লেখে, তাই 996, তারপর 1056. শেষ তিন লাইন: দুটি swap-ই আলাদা ঘরে ঠিক কাজ করে। একই ঘর দুবার পাঠালে temp-ওয়ালা swap নিরীহ (p = 8 থাকে), কিন্তু যোগ-বিয়োগের swap মানটিকেই শূন্য করে দেয়। কোনো warning আসেনি: compiler জানে না দুটি reference একই ঘর।

শেষ লাইনটি কেন 0, ধাপে ধাপে দেখুন। আগে আলাদা দুই ঘরে, তারপর একই ঘরে:

1void swap_add(int &x, int &y) {2    x = x + y;3    y = x - y;4    x = x - y;5}6swap_add(p, q);  // p=5, q=87swap_add(p, p);  // one box
এই ধাপের পরে
x →, y →
p
q
  1. দুই ঘর। x বাঁধা p-এর ঘরে, y বাঁধা q-এর ঘরে। p = 5, q = 8.
  2. x = x + y. p = 5 + 8 = 13.
  3. y = x - y. q = 13 − 8 = 5: পুরোনো p এখন q-তে।
  4. x = x - y. p = 13 − 5 = 8. অদলবদল সম্পূর্ণ: p = 8, q = 5.
  5. এক ঘর। এবার swap_add(p, p): x আর y দুটিই p-এর ঘর। p = 8. এখন x, y আর p একই ঘরের তিনটি নাম।
  6. x = x + y. p = 8 + 8 = 16.
  7. y = x - y. x আর y একই ঘর, তাই এটি আসলে p = p − p = 0. মূল মান এখানেই হারিয়ে গেল।
  8. x = x - y. p = 0 − 0 = 0. সত্যিকারের run-এর শেষ লাইন swap_add(p, p): p=0 ঠিক এটাই। Swap-এর নিয়ম “নিজের সঙ্গে অদলবদল কিছুই বদলায় না” ভেঙে গেল।

এমন ভুল বাস্তবে কীভাবে আসে? প্রায় কখনো কেউ সরাসরি swap(p, p) লেখেন না। আসে swap(a[i], a[j]) থেকে, যখন কোনো এক ইনপুটে i = j: যেমন একটি sorting algorithm যেখানে কখনো কখনো একটি উপাদান নিজের সঙ্গেই অদলবদল হয়। Parameter passing-এ aliasing-এর তিনটি সাধারণ উৎস মনে রাখুন:

  • একই actual দুবার: f(x, x), বা f(a[i], a[j]) যখন i = j.
  • Global আর parameter: অংশ ৩-এর f(g)-এ function-এর ভেতরে g আর x একই ঘর।
  • Array আর তার উপাদান: f(a, a[0]): একটি parameter পুরো array, অন্যটি তারই একটি ঘর।

এর পরিণতি দুই দিকে। Correctness-এর দিকে, উপরের মতো ভুল উত্তর। Performance-এর দিকে, compiler-কে ধরে নিতে হয় যে দুটি reference parameter একই ঘর হতে পারে, তাই একটিতে লেখার পরে অন্যটির মান আবার মেমরি থেকে পড়তে হয়। পর্ব ২৩-এ restrict দিয়ে ঠিক এটিই সত্যিকারের assembly-তে দেখেছেন; সেখানকার আলোচনা আর এখানে পুনরাবৃত্তি করছি না।

৫ · Value-result — copy back-এর ক্রম আর ঠিকানার সময়

Call by value-result (copy-in copy-out নামেও পরিচিত) reference-এর মতোই in-out, কিন্তু function চলার সময় ডাকা-পক্ষের ঘর ছোঁয় না। তাতে দুটি সুবিধা। এক, function-এর ভেতরে প্রতিটি পড়া-লেখা নিজের local ঘরে, তাই দ্রুত, আর মাঝপথে অন্য কেউ (যেমন অন্য একটি thread বা একটি alias) মান বদলালেও ভেতরের হিসাব নড়ে না। দুই, function মাঝপথে ব্যর্থ হলে (কিছু ভাষায় exception হলে) copy back না-ও হতে পারে, তাই ডাকা-পক্ষ অর্ধেক-বদলানো মান দেখে না; এটি ভাষাভেদে আলাদা, তাই ভাষার নিয়ম দেখে নিতে হয়।

কিন্তু aliasing থাকলে value-result দুটি নতুন প্রশ্ন তোলে, যা reference-এ ছিল না: কোন ঠিকানায় copy back (অংশ ৩-এর সতর্কতা), আর একাধিক out parameter একই ঘরে গেলে কোন ক্রমে। দ্বিতীয়টি দেখুন (আবার Haat-এর বর্ধিত রূপ, এবার inout চিহ্ন দিয়ে):

1var a = 0;2fn two(inout x: Int, inout y: Int) {3    x = 1;4    y = 2;5}6two(a, a);7print(a);
এই ধাপের পরে
x, y (কপি)
a: বাঁ → ডান
a: ডান → বাঁ
a: reference
  1. Copy in. দুটি parameter-ই a থেকে কপি পায়: x = 0, y = 0. দুটির ফেরার ঠিকানাই a. Reference হলে x, y আর a একই ঘর হতো।
  2. x = 1. Value-result-এ শুধু local x বদলায়, a = 0. Reference-এ a = 1.
  3. y = 2. Value-result-এ y = 2, a তখনো 0. Reference-এ a = 2.
  4. প্রথম copy back. বাঁ থেকে ডান ক্রমে আগে x: a = 1. ডান থেকে বাঁ ক্রমে আগে y: a = 2.
  5. দ্বিতীয় copy back. বাঁ → ডান: এবার y, a = 2. ডান → বাঁ: এবার x, a = 1. যে শেষে লেখে, সে-ই জেতে।
  6. আউটপুট। একই program-এর উত্তর 2 বা 1, শুধু বাস্তবায়নের পছন্দের ওপর নির্ভর করে; reference দেয় 2. মানগুলো লেখকের যন্ত্রে simulator-এর বহু-parameter রূপ চালিয়ে মেলানো। এজন্য ভাষাগুলো হয় ক্রম বেঁধে দেয়, নয়তো এমন aliasing-ই নিষেধ করে।

বাস্তব ভাষাগুলো কী করে? Ada-র in out parameter-এ ছোট scalar type (Integer, Boolean) কপি দিয়ে যায়, আর কিছু type (যেমন tagged type) reference দিয়ে; বাকিগুলোর জন্য standard বাস্তবায়নকে বেছে নিতে দেয়। ফলে যে program দুই পথে আলাদা ফল দেয়, Ada তাকে নির্ভরযোগ্য program বলে মানে না, আর Ada 2012 এমন কিছু স্পষ্ট aliasing (একই variable দুটি out/in out argument-এ) compile-এর সময়েই আটকানোর নিয়ম এনেছে বলে জানা যায়। Swift-এর ডকুমেন্টেশন inout-কে সরাসরি “copy-in copy-out বা call by value result” বলে, আর বলে যে ঘরটি মেমরিতে থাকলে optimization হিসেবে একই ঘর ব্যবহার হতে পারে (অর্থাৎ বাস্তবে reference). দুই আচরণ যাতে আলাদা না হয়, সেজন্য Swift 5-এর exclusivity নিয়ম একই variable দুটি inout-এ পাঠানোকে compile error করে (উদাহরণ, এখানে চালানো হয়নি):

// উদাহরণ (Swift 5), চালানো হয়নি
func two(_ x: inout Int, _ y: inout Int) { x = 1; y = 2 }
var a = 0
two(&a, &a)   // error: overlapping accesses to 'a'

নকশার শিক্ষা পরিষ্কার: copy আর reference-এর পার্থক্য দেখা দেয় শুধু aliasing থাকলে। তাই হয় aliasing নিষেধ করুন (Swift, Rust-এর &mut), নয়তো প্রোগ্রামারকে জানিয়ে দিন যে কোনটি ঘটবে (C++ reference, Pascal var). অনুশীলন ৪-এ আপনি এটি প্রমাণ করবেন: aliasing না থাকলে value-result আর reference সবসময় একই store দেয়।

৬ · Call by sharing — Python, Java আর JavaScript-এর নিয়ম

পর্ব ২৩-এ দেখেছেন, managed ভাষায় variable-এ থাকে object-এর দিকে একটি তীর। Call by sharing মানে এই তীরের মানটি by value যায়। তাই এটি আসলে Call-V নিয়মই, যেখানে v হলো একটি reference. ফল দুটি: object-এর ভেতর বদলানো (mutation) ডাকা-পক্ষ দেখে, কিন্তু parameter-কে নতুন object-এ সরানো (rebinding) দেখে না। Java-র language specification একে সোজাসুজি pass by value বলে, Python-এর ডকুমেন্টেশন বলে “call by object reference”; নাম আলাদা, আচরণ এক। বিভ্রান্তি আসে কারণ C++-এর “by reference” বোঝায় variable-টিই, আর এখানে শুধু object. Python-এ চালিয়ে দেখুন:

def add_item(cart, item):
    print("  inside, same object?", id(cart) == caller_id)
    cart.append(item)          # mutation: the caller sees it
    cart = ["new list"]        # rebinding: only the local name moves
    return len(cart)
cart = ["chal"]
caller_id = id(cart)
print("returned", add_item(cart, "dal"), "| cart =", cart)
def bump(n):                   # ints are immutable: n = n + 1 makes a new int
    n = n + 1
    return n
qty = 5
print("bump ->", bump(qty), "| qty =", qty)

def bad_cart(item, cart=[]):   # default made ONCE, when def runs
    cart.append(item)
    return cart
print("bad: ", bad_cart("chal"), bad_cart("dal"))

def good_cart(item, cart=None):
    cart = [] if cart is None else cart
    cart.append(item)
    return cart
print("good:", good_cart("chal"), good_cart("dal"))

def order(*items, fee=60, **notes):   # variadic, keyword-only, extra keywords
    return f"{len(items)} items, fee {fee}, notes {notes}"
print(order("chal", "dal", fee=0, city="Khulna"))
def ship(city, /, *, express):       # city: positional only; express: keyword only
    return city + (" (express)" if express else "")
print(ship("Rajshahi", express=True))
try:
    ship("Rajshahi", True)
except TypeError as e:
    print("TypeError:", e)

আসল আউটপুট (CPython 3.14.4; Pyodide-এ একই):

  inside, same object? True
returned 1 | cart = ['chal', 'dal']
bump -> 6 | qty = 5
bad:  ['chal', 'dal'] ['chal', 'dal']
good: ['chal'] ['dal']
2 items, fee 0, notes {'city': 'Khulna'}
Rajshahi (express)
TypeError: ship() takes 1 positional argument but 2 were given

প্রথম দুই লাইন: function-এর ভেতরের cart আর বাইরের cart একই object (id সমান); append সেই object বদলায়, তাই বাইরে 'dal' দেখা যায়। পরের cart = ["new list"] শুধু local নামটি সরায়, তাই ফেরত 1 কিন্তু বাইরের list অক্ষত। তৃতীয় লাইন: int অপরিবর্তনীয় (immutability), তাই n = n + 1 নতুন int বানিয়ে শুধু n সরায়; Python-এ “int by value যায়” কথাটি ভুল হলেও ফল by value-এর মতোই। চতুর্থ লাইন একটি বিখ্যাত ফাঁদ, পরের অংশে ব্যাখ্যা। শেষ চার লাইন argument মেলানোর নিয়ম: *items বাড়তি positional argument tuple-এ জড়ো করে, **notes বাড়তি keyword argument dict-এ; /-এর আগের parameter শুধু অবস্থান দিয়ে, *-এর পরেরগুলো শুধু নাম দিয়ে দেওয়া যায়, তাই ship("Rajshahi", True) TypeError.

Sharing-এর একটি সহজ পরীক্ষা মনে রাখুন, যা যেকোনো ভাষায় চলে: একটি swap function লিখুন যেটি দুটি parameter-কে অদলবদল করে (t = a; a = b; b = t). ডাকা-পক্ষের দুটি variable বদলালে ভাষাটি by reference; না বদলালে by value বা sharing. Java-তে swap(Integer a, Integer b) কখনো কাজ করে না, Python-এ def swap(a, b)-ও না। এজন্য Python-এ swap লেখা হয় a, b = b, a দিয়ে, function ছাড়াই।

৭ · কপির খরচ — const reference, move আর ABI

By value-এর একটি লুকানো দাম আছে: বড় object হলে প্রতিটি call-এ পুরোটা কপি। C++-এ ৮টি long-এর একটি struct (৬৪ byte) একবার by value আর একবার const reference দিয়ে পাঠিয়ে দেখি compiler কী বানায়:

struct Order { long qty[8]; };            // 64 bytes

long sum_val(Order o);                    // by value: callee gets a copy
long sum_ref(const Order &o);             // by const reference: an address

long call_val(Order &o) { return sum_val(o); }
long call_ref(Order &o) { return sum_ref(o); }
~/haat $ zig c++ -std=c++20 -O2 -g0 -S --target=x86_64-linux-musl \
      -fno-asynchronous-unwind-tables -fomit-frame-pointer cost.cpp -o cost.s
~/haat $ cat cost.s        # trimmed: directives and comments removed
_Z8call_valR5Order:
        subq    $72, %rsp
        movups  (%rdi), %xmm0
        movups  16(%rdi), %xmm1
        movups  32(%rdi), %xmm2
        movups  48(%rdi), %xmm3
        movups  %xmm3, 48(%rsp)
        movups  %xmm2, 32(%rsp)
        movups  %xmm1, 16(%rsp)
        movups  %xmm0, (%rsp)
        callq   _Z7sum_val5Order
        addq    $72, %rsp
        retq
_Z8call_refR5Order:
        jmp     _Z7sum_refRK5Order              # TAILCALL

সত্যিকারের run, Clang 22.1.8, x86-64 Linux target. call_val stack-এ ৭২ byte জায়গা নেয়, চারটি ১৬-byte movups দিয়ে ৬৪ byte পড়ে আর চারটি দিয়ে stack-এ লেখে, তারপর ডাকে: এটাই by value-এর কপি। এই target-এর calling convention (System V AMD64) ১৬ byte-এর বড় struct-কে register-এ নয়, memory-তে কপি করে পাঠায়। call_ref-এ কপিই নেই: ঠিকানাটি আগে থেকেই %rdi-তে, তাই compiler সরাসরি jmp করেছে (tail call, পর্ব ৩২-এ)। আর const নিশ্চিত করে যে sum_ref reference দিয়ে object বদলাতে পারবে না (type checker-এর স্তরে), তাই নিরাপত্তায় এটি by value-এর কাছাকাছি, খরচে reference-এর মতো। Calling convention-এর পূর্ণ বিবরণ পর্ব ৭১-এ।

তাহলে সবসময় const reference? না। ছোট type-এ (int, double, দুই-তিন field-এর struct) by value প্রায়ই সমান বা বেশি দ্রুত, কারণ মান সরাসরি register-এ যায়, আর callee-কে ঠিকানা থেকে পড়তে হয় না; reference দিলে আবার aliasing-এর প্রশ্ন ওঠে (অংশ ৪)। প্রচলিত নিয়ম: ছোট আর সস্তা-কপির type by value, বড় type যা শুধু পড়বেন তা const T&, আর যে object function নিজের কাছে রেখে দেবে (যেমন একটি list-এ যোগ করবে) তা by value নিয়ে ভেতরে move করা। C++11-এর move semantics কপির বদলে ভেতরের মেমরি-খণ্ডটি হস্তান্তর করে; বিস্তারিত C++ কোর্সের পর্ব ৩৬-এ।

Rust এই তিনটি পথকে type-এ স্পষ্ট করে: fn f(o: Order) মানে মালিকানা হস্তান্তর (move; type Copy হলে কপি), fn f(o: &Order) মানে শুধু-পড়ার ধার, আর fn f(o: &mut Order) মানে বদলানোর ধার, যা একই সময়ে আর কারও থাকতে পারে না। শেষ নিয়মটিই অংশ ৪-এর swap-ফাঁদ compile-এর সময়ে আটকায়: swap(&mut p, &mut p) borrow checker পাস করে না (উদাহরণ, এখানে চালানো হয়নি; পুরো গল্প পর্ব ৭৬-এ)।

৮ · Default, keyword আর variadic argument — argument মেলানোর নিয়ম

Parameter passing-এর আরেকটি অংশ হলো call-এর argument-গুলো কোন parameter-এ যাবে, তা ঠিক করা। তিনটি সুবিধা প্রায় সব আধুনিক ভাষায় কোনো না কোনো রূপে আছে: default argument (না দিলে আগে থেকে ঠিক করা মান), keyword argument (নাম ধরে দেওয়া, ক্রমের ঝামেলা নেই) আর variadic function (যত খুশি argument). নকশার বড় প্রশ্নটি হলো default মান কখন হিসাব হয়, আর সেখানে ভাষাগুলো একমত নয়:

ভাষাDefault কখন হিসাবফল
Pythondef চলার সময়, একবারMutable default সব call-এ ভাগ হয় (অংশ ৬-এর bad_cart)
JavaScript (ES2015+)প্রতিটি call-এ, বাঁ থেকে ডানেপ্রতিবার নতুন object; আগের parameter ব্যবহার করা যায়
C++প্রতিটি call-এ, compiler call-এর জায়গায় বসায়Virtual function-এ default আসে static type থেকে
Java, C, Haat v1Default নেইJava-তে overloading দিয়ে অনুকরণ

Python-এর bad_cart দুবার ডাকার পরে দুটি ফলই ['chal', 'dal'] দেখাল, কারণ দুটি ফল আসলে একই list: def চলার সময় একবার তৈরি হওয়া default object. JavaScript এর উল্টো পথ নিয়েছে। নিচের JS block-এ পাঁচটি বিষয় একসঙ্গে: call-time default, rest parameter, object দিয়ে “নামওয়ালা” argument, পুরোনো sloppy mode-এর arguments object যে আসলে parameter-এর alias, আর sharing.

// 1. default values are computed at every call (left to right)
let made = 0;
function newCart(items = [], id = ++made) { items.push("chal"); return id + ":" + items.length; }
console.log("defaults:", newCart(), newCart(), "made =", made);

// 2. rest parameter: any number of arguments, collected in a real array
function total(fee, ...prices) { return prices.reduce((s, p) => s + p, fee); }
console.log("rest:", total(60, 520, 520), "| spread:", total(0, ...[100, 200]));

// 3. "named" arguments: pass one object and destructure it
function ship({ city, express = false }) { return city + (express ? " (express)" : ""); }
console.log("named:", ship({ express: true, city: "Rajshahi" }));

// 4. sloppy-mode arguments object is an alias of the parameters
function sloppy(x) { arguments[0] = 99; return x; }
function strict(x) { "use strict"; arguments[0] = 99; return x; }
console.log("arguments alias:", sloppy(1), "| strict:", strict(1));

// 5. sharing: mutation is visible, rebinding is not
function addItem(cart) { cart.push("dal"); cart = ["new"]; return cart.length; }
const cart = ["chal"];
console.log("sharing:", addItem(cart), cart.join(","));

আসল আউটপুট (ব্রাউজারের JavaScript; লেখকের যন্ত্রে Node 24.15-এও হুবহু এক):

defaults: 1:1 2:1 made = 2
rest: 1100 | spread: 300
named: Rajshahi (express)
arguments alias: 99 | strict: 1
sharing: 1 chal,dal

প্রথম লাইন: দুটি call-এই items নতুন খালি array পেল (দুটিতেই দৈর্ঘ্য 1), আর id-এর default ++made প্রতিবার চলল, তাই 1, তারপর 2. Python-এর bad_cart-এর সঙ্গে তুলনা করুন। দ্বিতীয় লাইন: ...prices বাকি argument-গুলো একটি সত্যিকারের array-তে নেয়: 60 + 520 + 520 = 1100. তৃতীয় লাইন: JavaScript-এ keyword argument নেই, তাই একটি object পাঠিয়ে তা destructure করা হয়; ক্রম উল্টে দিলেও কাজ করে। চতুর্থ লাইন সবচেয়ে আশ্চর্যের: পুরোনো (sloppy) mode-এ সাধারণ parameter-ওয়ালা function-এর arguments[0] আর x একই ঘর, তাই একটিতে লেখা অন্যটিতে দেখা যায়, যেন by reference-এর একটি লুকানো alias. Strict mode এই সংযোগ কেটে দেয়: 1. শেষ লাইন: অংশ ৬-এর sharing, এবার JavaScript-এ।

Variadic function-এর নকশায় সবচেয়ে বড় প্রশ্ন type-নিরাপত্তা। C-র printf(const char *fmt, ...)-এ বাড়তি argument-গুলোর type compiler নিয়ম মেনে যাচাই করতে পারে না; ছোট type বড় হয়ে যায় (float থেকে double, char থেকে int, যাকে বলে default argument promotion), আর callee va_arg দিয়ে অনুমান করে পড়ে। ভুল type-এ পড়া undefined behavior; GCC আর Clang শুধু format string দেখে -Wformat সতর্কতা দেয়। Java-র int... xs আর Python-এর *args নিরাপদ, কারণ বাড়তি argument-গুলো একটি সাধারণ array বা tuple হয়ে আসে। Java varargs-এর বিস্তারিত Java কোর্সের পর্ব ১২-এ, আর Python-এর default ও keyword argument Python কোর্সের পর্ব ১৩-এ।

৯ · Haat-এ parameter passing — মান, closure আর compiler-এর চোখ

Haat v1-এ নিয়ম সরল: সব argument by value. Int, Bool আর Str অপরিবর্তনীয়, তাই কপি আর sharing-এর পার্থক্য চোখে পড়ে না। Function মানও by value যায়, আর একটি closure-এর মান হলো তার code আর ধরে রাখা cell-গুলোর reference. এখান থেকেই একটি কৌশল আসে: Haat-এ by-reference না থাকলেও একটি out parameter-এর কাজ closure দিয়ে করা যায়, একটি “পড়ার” আর একটি “লেখার” function পাঠিয়ে। সত্যিকারের run:

// বাজারঘর: Haat v1-এ মান যায়, ঘর যায় না
fn add_fee(total: Int, fee: Int) -> Int {
    return total + fee;
}
fn add_fee_ref(get: () -> Int, set: (Int) -> Unit, fee: Int) {
    set(get() + fee);
}
var total = 936;
print(add_fee(total, 60));
print(total);
add_fee_ref(fn() -> Int { return total; }, fn(v: Int) { total = v; }, 60);
print(total);
~/haat $ python haat.py run fee.haat
996
936
996
~/haat $ python haat.py dis fee.haat      # parts, trimmed
== <main> (arity 0, locals 0) ==
   6  LOAD_GLOBAL    0     ; add_fee
   7  LOAD_GLOBAL    2     ; total
   8  CONST          3     ; 60
   9  CALL           2
  ...
  13  LOAD_GLOBAL    1     ; add_fee_ref
  14  MAKE_CLOSURE   4     ; <fn lambda@11:13>
  15  MAKE_CLOSURE   5     ; <fn lambda@11:44>
  16  CONST          3     ; 60
  17  CALL           3
== add_fee_ref (arity 3, locals 3) ==
   0  LOAD_LOCAL     1     ; set
   1  LOAD_LOCAL     0     ; get
   2  CALL           0
   3  LOAD_LOCAL     2     ; fee
   4  ADD
   5  CALL           1
== lambda@11:44 (arity 1, locals 1) ==
   0  LOAD_LOCAL     0     ; v
   1  STORE_GLOBAL   2     ; total

সত্যিকারের run (Haat reference, CPython 3.14.4; vm দিয়েও একই তিন লাইন)। add_fee শুধু মান পায়: 996 ফেরত দেয়, কিন্তু total 936-ই থাকে। add_fee_ref পায় দুটি closure, আর set-এর ভেতরের STORE_GLOBAL 2 সরাসরি total-এর ঘরে লেখে, তাই শেষ লাইনে 996. Bytecode-এ by value কেমন দেখায় তাও স্পষ্ট: ডাকা-পক্ষ argument-গুলোর মান stack-এ রাখে (LOAD_GLOBAL 2 total-এর মান, CONST 3 60), তারপর CALL 2; callee সেগুলো নিজের local slot 0 আর 1 হিসেবে পায়। লক্ষ করুন add_fee_ref-এ আগে set (callee), তারপর get() (argument): নকশা-সিদ্ধান্ত ১২-এর “callee before arguments”. Stack frame আর slot-এর পুরো ছবি পরের পর্বে।

এই get/set জোড়া আপনার চেনা: পর্ব ১৯-এর thunk, শুধু একটি লেখার দিকসহ। ALGOL 60-এর compiler-গুলো call by name ঠিক এভাবেই বানাত: প্রতিটি by-name argument-এর জন্য একটি ছোট function, যা ডাকা-পক্ষের environment-এ ঠিকানা হিসাব করে দেয়। আর by reference হলো এর একটি সরল রূপ, যেখানে ঠিকানাটি একবারই, call-এর সময়ে হিসাব হয়। একটি compiler-এর চোখে তাই পুরো পরিবারটি একটি প্রশ্নে নেমে আসে: argument-এর l-value বা r-value কে, কখন আর কতবার হিসাব করে?

মডেলCaller কী পাঠায়কখন হিসাবCallee-তে x পড়া
ValueমানCall-এর আগে, একবারনিজের slot
ReferenceঠিকানাCall-এর আগে, একবারঠিকানা থেকে load
Value-resultমান আর ঠিকানাCall-এর আগে; ফেরার পরে storeনিজের slot
SharingObject-এর reference (মান)Call-এর আগে, একবারনিজের slot, তারপর object
NameThunk (code + environment)প্রতিটি ব্যবহারেThunk ডাকা

যদি Haat-এ একদিন ref parameter যোগ করতে চান (Haat-এর বর্ধিত রূপ), তাহলে compiler-এর তিনটি জায়গায় কাজ। Parser: ref একটি নতুন keyword, parameter-এর আগে। Resolver আর type checker: ref-এর argument অবশ্যই একটি var নাম হতে হবে (literal, let বা parameter নয়, নকশা-সিদ্ধান্ত ১৯-এর সঙ্গে মিল রেখে), আর একই call-এ একই var দুবার নয়, যাতে অংশ ৪-এর ফাঁদ না থাকে। VM: একটি নতুন opcode যা ঘরটিকে একটি cell-এ তোলে আর cell-টি পাঠায়, ঠিক closure যেভাবে cell ধরে। অনুশীলন ১-এ এর যাচাই-অংশটি নিজে বানাবেন।

আরও গভীরে: FORTRAN-এর প্রথম দিকের compiler-গুলো সাধারণত argument-এর ঠিকানা পাঠাত, আর literal-এর জন্যও একটি ঘরের ঠিকানা; কিছু পুরোনো বাস্তবায়নে CALL INC(1)-এর মতো call নাকি সেই ঘরের মান বদলে দিত, ফলে program-এর অন্য জায়গায় “1” আর 1 থাকত না। কাহিনিটি বহুল প্রচলিত, তবে কোন compiler-এ ঠিক কী হয়েছিল তা উৎসভেদে আলাদা। Fortran standard নিজে বাস্তবায়ন বেঁধে দেয় না: copy-in copy-out আর reference দুটিই বৈধ, আর যে program দুই পথে আলাদা ফল দেয়, standard তাকে অবৈধ বলে। এই একই চিন্তা আজ Swift-এর exclusivity আর Rust-এর &mut-এ type system-এর অংশ।

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:

  • Call by value আর call by reference-এর পার্থক্য? Value-তে callee কপি পায়, ডাকা-পক্ষ অক্ষত; reference-এ callee ঠিকানা পায়, প্রতিটি লেখা ডাকা-পক্ষে পড়ে।
  • Value-result আর reference কবে আলাদা? শুধু aliasing থাকলে: একই variable দুবার, বা global আর parameter একই ঘর।
  • Java কি by reference? না; সবসময় by value, object-এর বেলায় reference-এর মান কপি হয় (sharing).
  • Python-এ mutable default argument-এর সমস্যা? Default একবার def-এর সময়ে তৈরি হয়, তাই সব call একই list ভাগ করে; None দিয়ে সমাধান।
  • বড় object কীভাবে পাঠাবেন (C++)? শুধু পড়লে const T&; নিজের কাছে রাখলে by value নিয়ে move.

১০ · AI-এর যুগে parameter passing

Parameter passing-এর প্রশ্নে AI assistant প্রায়ই এক ভাষার নিয়ম অন্য ভাষায় চাপায়, আর হাতে-করা trace-এ ধাপ বাদ দেয়। এই বিষয়ে বারবার দেখা ভুল আর ধরার উপায়:

AI-এর ভুলকীভাবে ধরবেন
“Python/Java pass by reference” বলাSwap function লিখে চালানো; parameter-কে নতুন object-এ সরিয়ে ডাকা-পক্ষ দেখা
Value-result-এর trace-এ copy back ভুলে যাওয়া, বা ঠিকানা কখন নেওয়া হলো না বলাঅংশ ৩-এর মতো ছোট interpreter-এ চালিয়ে মেলানো; প্রশ্নের অনুমান লিখে রাখা
Aliasing-এর ক্ষেত্র বাদ দিয়ে “reference আর value-result একই” বলাf(x, x) আর f(a[i]) দিয়ে differential test
বড় object-এ কপি নেই বা আছে বলে অনুমানCompiler-এর -S output দেখা (অংশ ৭-এর মতো)
“Optimization” হিসেবে by value-কে reference-এ বদলানো, অথচ callee parameter বদলায়আগের আর পরের কোড একই ইনপুটে চালিয়ে ফল তুলনা
Default argument কখন হিসাব হয়, সব ভাষায় এক ধরে নেওয়াDefault-এ একটি counter বা list রেখে দুবার ডেকে দেখা

AI-কে ভালোভাবে কাজে লাগানোর উপায়: ভাষা আর version বলে দেওয়া, প্রতিটি parameter-এর mode আলাদা করে চাওয়া, আর trace-এর প্রতিটি ধাপে store-এর অবস্থা লিখতে বলা।

আমি প্রোগ্রামিং ভাষার parameter passing শিখছি। নিচের program-টি [C++20 / Java 21 / Python 3.14 / JavaScript / একটি কাল্পনিক ভাষা] -এর। তুমি: ১. প্রতিটি parameter কোন mode-এ (in, out, in-out) আর কোন মডেলে (value, reference, value-result, sharing, name) যায়, ভাষার নিয়ম উদ্ধৃত করে বলো। ২. প্রতিটি statement-এর পরে প্রতিটি variable-এর মান একটি টেবিলে লেখো; value-result হলে ঠিকানা কখন নেওয়া হলো আর copy back-এর ক্রম স্পষ্ট বলো। ৩. কোথাও দুটি নাম একই ঘর দেখায় (aliasing) কি না দেখাও। ৪. কোনো আচরণ ভাষায় unspecified বা undefined হলে স্পষ্ট লেখো; অনুমান করে আউটপুট লিখবে না। ৫. আমি নিজে কোন ছোট পরীক্ষা চালিয়ে তোমার উত্তর মেলাব, তা বলো। [এখানে program]

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

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১FORTRAN-এর ঠিকানা থেকে Pascal-এর var আর Ada-র mode — ভাষাগুলো কেন “কীভাবে” ছেড়ে “কী” বলতে শিখল?

প্রথম দিকের ভাষাগুলোতে parameter passing ছিল বাস্তবায়নের একটি পার্শ্বফল। FORTRAN (১৯৫৭)-এর compiler-গুলোর কাছে সবচেয়ে সস্তা পথ ছিল argument-এর ঠিকানা পাঠানো, আর ভাষার আচরণ অনেকটাই সেই পছন্দ থেকে এল। ALGOL 60 প্রথম একটি স্পষ্ট নিয়ম লিখল: ডিফল্টে by name, আর value ঘোষণা করলে by value. কিন্তু by name-এর খরচ আর অপ্রত্যাশিত আচরণ (পর্ব ১৯) পরের ভাষাগুলোকে সরল পথে ঠেলে দিল।

Niklaus Wirth-এর Pascal (১৯৭০) দুটি পথ রাখল: সাধারণ parameter by value, আর var parameter by reference. এটি একটি বাস্তবায়ন-নাম, কিন্তু প্রোগ্রামারের উদ্দেশ্যও প্রকাশ করে: “এই parameter দিয়ে আমি ফল ফেরত দেব।” সমস্যা হলো, বড় array শুধু পড়ার জন্যও প্রোগ্রামাররা var লিখতেন, কপির খরচ বাঁচাতে; ফলে কোড পড়ে বোঝা যেত না কোনটি সত্যিই বদলায়।

Ada (১৯৮৩) প্রশ্নটি উল্টে দিল। প্রোগ্রামার লেখেন উদ্দেশ্য: in, out, in out. Compiler বাস্তবায়ন বেছে নেয়: ছোট scalar কপি দিয়ে, বড় বা বিশেষ type reference দিয়ে। in parameter-এ লেখা compile error, তাই বড় array-ও কপি ছাড়া নিরাপদে পড়া যায়। এর দাম অংশ ৫-এ দেখেছেন: aliasing থাকলে দুই বাস্তবায়নের ফল আলাদা, তাই Ada এমন program-কে নির্ভরযোগ্য মানে না, আর পরে এমন কিছু aliasing compile-এর সময় ধরার নিয়ম যোগ করেছে বলে জানা যায়।

আধুনিক ভাষায় এই ধারা চলছে। C# ref, out আর in দিয়ে উদ্দেশ্য লেখায়, আর out-এর বেলায় compiler নিশ্চিত করে যে ফেরার আগে মান বসানো হয়েছে। Swift inout-কে সংজ্ঞায় copy-in copy-out বলে, কিন্তু বাস্তবায়নে reference ব্যবহার করে, আর exclusivity নিয়মে পার্থক্য দেখা দেওয়ার পথ বন্ধ করে। Rust উদ্দেশ্যকে type-এই লেখে: &T, &mut T, না move.

মূল উপলব্ধি: mode (উদ্দেশ্য) প্রোগ্রামারের জন্য, মডেল (বাস্তবায়ন) compiler-এর জন্য। দুটি আলাদা রাখলে compiler দ্রুত পথ বেছে নিতে পারে, কিন্তু তখন ভাষাকে নিশ্চিত করতে হয় যে কোনো program সেই পছন্দের ওপর নির্ভর করে না।

প্র ০২“Java কি pass by reference?” — এই বিতর্ক কেন বারবার ফিরে আসে, আর পরিভাষা দিয়ে কীভাবে মেটানো যায়?

বিতর্কের মূল কারণ, “reference” শব্দটি দুটি স্তরে ব্যবহার হয়। Java-তে object-এর দিকে থাকা তীরের নাম reference. আবার parameter passing-এর পরিভাষায় “call by reference” মানে callee ডাকা-পক্ষের variable-এর ঘরটি পায়, যেমন C++-এর int& বা Pascal-এর var. Java-তে একটি object পাঠালে callee object-এর reference পায়, variable-এর ঘর নয়। তাই “Java object by reference পাঠায়” কথাটি প্রথম অর্থে সত্য, দ্বিতীয় অর্থে মিথ্যা।

Java Language Specification এখানে স্পষ্ট: method-এর প্রতিটি parameter একটি নতুন variable, যা argument-এর মান দিয়ে শুরু হয়; অর্থাৎ by value. Object-এর বেলায় সেই মানটি নিজেই একটি reference. এই নির্দিষ্ট আচরণের জন্য একটি আলাদা নাম আছে: Barbara Liskov-এর CLU ভাষার (১৯৭০-এর দশক) সময় থেকে প্রচলিত “call by sharing”. নামটি জনপ্রিয় হয়নি, তাই আজও অনেকে Python-কে “pass by object reference” আর Java-কে “pass by value of the reference” বলেন। সবগুলো একই জিনিস বোঝায়।

পার্থক্যটি শুধু তাত্ত্বিক নয়। একটি সহজ পরীক্ষা: একটি function লিখুন যা parameter-কে নতুন object-এ সরায় (o = new Order())। By reference হলে ডাকা-পক্ষের variable-ও নতুন object দেখত; Java-তে দেখে না। আরেকটি পরীক্ষা swap: Java-তে দুটি variable অদলবদল করা method লেখা যায় না। এই দুটি পরীক্ষা প্রমাণ করে Java-র মডেল sharing, reference নয়। Python আর JavaScript-এও একই।

পরিভাষা মেটানোর একটি পরিষ্কার উপায় হলো দুটি প্রশ্ন আলাদা করা। প্রশ্ন এক: কী কপি হয়? (মান, ঠিকানা, না কিছুই না)। প্রশ্ন দুই: সেই মান কি নিজেই একটি reference? Java-র উত্তর: মান কপি হয়, আর object-এর বেলায় সেই মান একটি reference. C++-এর int&-এর উত্তর: কোনো মান কপি হয় না, variable-এর ঘরই ভাগ হয়।

মূল উপলব্ধি: “by reference” আর “reference type” দুটি আলাদা ধারণা। Swap আর rebinding-এর পরীক্ষা যেকোনো ভাষায় চালিয়ে আপনি নিজেই মডেলটি নির্ণয় করতে পারেন, কারও দাবির ওপর নির্ভর না করে।

প্র ০৩বড় object পাঠানোর চার পথ — copy, const reference, move আর borrow — কখন কোনটি, আর কেন?

সমস্যাটি পুরোনো: by value নিরাপদ কিন্তু বড় object-এ ব্যয়বহুল; by reference সস্তা কিন্তু callee বদলে দিতে পারে, আর aliasing আনে। অংশ ৭-এর সত্যিকারের assembly-তে ৬৪ byte কপির জন্য আটটি নির্দেশ দেখেছেন; একটি বড় string বা vector-এ কপি মানে heap-এ নতুন মেমরি নেওয়া আর পুরো বিষয়বস্তু কপি, যা অনেক বেশি দামি।

C++-এর প্রথম উত্তর ছিল const T&: খরচে reference, নিরাপত্তায় প্রায় value. কিন্তু “প্রায়”: const reference মানে এই পথে বদলানো যাবে না, অন্য পথে (একটি alias দিয়ে) object বদলাতে পারে, আর callee মানটি পরে ব্যবহারের জন্য রাখলে object-এর lifetime নিয়ে প্রশ্ন ওঠে (dangling reference, পর্ব ২৩)।

দ্বিতীয় উত্তর C++11-এর move semantics: যে object ডাকা-পক্ষের আর লাগবে না (একটি temporary, বা std::move করা variable), তার ভেতরের মেমরি-খণ্ড কপি না করে হস্তান্তর। এতে “by value নিয়ে ভেতরে move” কৌশলটি জনপ্রিয় হলো: callee নিজের কপি পায়, কিন্তু ডাকা-পক্ষ temporary দিলে কপির খরচ প্রায় নেই। আর C++17 থেকে কিছু ক্ষেত্রে copy elision বাধ্যতামূলক, যেখানে কপি বা move কোনোটিই হয় না।

তৃতীয় উত্তর Rust-এর: ডিফল্টে by value মানে move, অর্থাৎ ডাকা-পক্ষ আর পুরোনো variable ব্যবহার করতে পারে না (type Copy না হলে)। শুধু পড়তে চাইলে &T, বদলাতে চাইলে &mut T, আর borrow checker নিশ্চিত করে যে reference object-এর চেয়ে বেশি দিন বাঁচে না আর &mut-এর সময় আর কোনো পথ নেই। এখানে const reference-এর “প্রায়” সমস্যাটি নেই: &T থাকাকালীন কেউ object বদলাতে পারে না।

GC-ভাষা (Java, Python) সমস্যাটি অন্যভাবে এড়ায়: সব object sharing দিয়ে যায়, কপি কখনো স্বয়ংক্রিয় নয়। দাম হলো, callee object বদলাবে কি না তা type-এ লেখা থাকে না; সেজন্য অপরিবর্তনীয় type (Java-র String, Python-এর tuple) আর defensive copy-র প্রথা।

মূল উপলব্ধি: প্রশ্নটি আসলে মালিকানার: callee কি object শুধু দেখবে, বদলাবে, না রেখে দেবে? যে ভাষা এই উত্তর type-এ লিখতে দেয়, সেখানে compiler খরচ আর নিরাপত্তা দুটিই একসঙ্গে নিশ্চিত করতে পারে।

প্র ০৪In-out parameter-এর aliasing ভাষাগুলো কেন নিষেধ করতে চায়, আর কীভাবে?

অংশ ৪ আর ৫ থেকে দুটি তথ্য পেয়েছেন। এক, aliasing থাকলে একই program reference আর value-result-এ আলাদা ফল দেয়, এমনকি value-result-এর ভেতরেও copy back-এর ক্রমভেদে। দুই, aliasing না থাকলে সবগুলো একই ফল দেয় (অনুশীলন ৪-এর প্রমাণ)। অর্থাৎ যে ভাষা aliasing নিষেধ করতে পারে, সে বাস্তবায়ন বেছে নেওয়ার পুরো স্বাধীনতা পায়, আর প্রোগ্রামার একটি পুরো ধরনের ভুল থেকে মুক্ত হন।

নিষেধের পথ তিন রকম। নিয়মে লেখা, যাচাই ছাড়া: Fortran standard বলে, একটি subroutine-এর যে argument-এ লেখা হয়, তা অন্য কোনো argument-এর alias হওয়া চলবে না; প্রোগ্রামার নিয়ম ভাঙলে program অবৈধ, কিন্তু compiler সাধারণত ধরে না। এর বিনিময়ে Fortran compiler সাহসের সঙ্গে optimize করতে পারে; সংখ্যা-হিসাবের library-তে Fortran-এর গতির সুনামের একটি প্রচলিত ব্যাখ্যা এটি। C99-এর restrict একই ধরনের প্রতিশ্রুতি, ঐচ্ছিকভাবে (পর্ব ২৩)।

Compile-এর সময়ে সহজ ক্ষেত্র ধরা: Swift-এর exclusivity নিয়ম একই variable দুটি inout-এ পাঠানো compile error করে; কিছু ক্ষেত্র (যেমন class-এর property) সে চলার সময়ে পরীক্ষা করে। Ada 2012-এর নিয়মও এই ধরনের বলে জানা যায়। সীমা হলো a[i] আর a[j]: i আর j সমান কি না, compile-এর সময় সাধারণত জানা যায় না, তাই এসব ক্ষেত্রে হয় চলার সময়ে পরীক্ষা, নয়তো পুরো array-কেই একটি জিনিস ধরা।

Type system-এ প্রমাণ: Rust-এর &mut বলে, এই reference থাকাকালীন ওই ঘরে আর কোনো পথ নেই। swap(&mut a[i], &mut a[j]) লেখাই যায় না, কারণ একই array থেকে দুটি &mut ধার; তার বদলে standard library-র a.swap(i, j) বা split_at_mut ব্যবহার করতে হয়, যার ভেতরের নিরাপত্তা library লেখক প্রমাণ করেন। দাম: কিছু বৈধ program-ও লিখতে ঘুরপথ লাগে।

মূল উপলব্ধি: parameter passing-এর প্রায় সব জটিলতা aliasing থেকে আসে। ভাষা যত নিশ্চিতভাবে aliasing বাদ দিতে পারে, তত সরল তার semantics আর তত সাহসী তার optimizer.

প্র ০৫Default, keyword আর variadic argument-এর নকশায় ভাষাগুলো কী কী ভুল করেছে, আর তা থেকে কী শেখা যায়?

Python-এর default: default মান def চলার সময় একবার হিসাব হয়। নকশাটি সরল আর দ্রুত (প্রতিটি call-এ নতুন করে হিসাব করতে হয় না), কিন্তু mutable default-এর ফাঁদ এত পরিচিত যে linter আর code review-এর চেকলিস্টে এটি প্রায় সবসময় থাকে। JavaScript (ES2015) পরে এসে উল্টো পথ নিয়েছে: প্রতিটি call-এ নতুন করে, যা অংশ ৮-এর run-এ দেখেছেন। শিক্ষা: “কখন হিসাব হয়” প্রশ্নটি নকশার শুরুতেই স্পষ্ট করা দরকার, পরে বদলানো যায় না।

C++-এর default আর virtual function: C++-এ default argument compiler call-এর জায়গায় বসায়, call-এর static type দেখে। তাই একটি base class pointer দিয়ে virtual function ডাকলে function আসে derived class থেকে (dynamic dispatch, পর্ব ০৮), কিন্তু default মান আসে base class থেকে। দুটি সিদ্ধান্ত দুটি আলাদা সময়ে হয় বলে এই মিশ্রণ; অনেক C++ নির্দেশিকা virtual function-এর default argument বদলাতে নিষেধ করে।

C-র variadic: printf-এর বাড়তি argument-এর type ভাষা জানে না, তাই ভুল format string মানে undefined behavior, আর একসময় format string-এ ব্যবহারকারীর ইনপুট বসানো ছিল একটি পরিচিত নিরাপত্তা-দুর্বলতা (format string vulnerability). Compiler-গুলো পরে format string পড়ে সতর্ক করা শিখেছে, কিন্তু সেটি ভাষার নিয়ম নয়, একটি বাড়তি বিশ্লেষণ। C++ পরে variadic template আর type-নিরাপদ std::format এনেছে, যেখানে argument-এর type compile-এর সময়ে জানা।

Keyword argument: নাম দিয়ে argument দেওয়া call পড়া সহজ করে (ship(city="Rajshahi", express=True)), কিন্তু parameter-এর নাম তখন public API-র অংশ হয়ে যায়: নাম বদলালে পুরোনো call ভাঙে। Python 3.8-এর positional-only parameter (/) ঠিক এই সমস্যার উত্তর, যাতে library লেখক কিছু নাম ভবিষ্যতে বদলানোর স্বাধীনতা রাখতে পারেন।

মূল উপলব্ধি: argument মেলানোর প্রতিটি সুবিধা একটি সময়ের প্রশ্ন (কখন হিসাব), একটি type-এর প্রশ্ন (কে যাচাই করে) আর একটি চুক্তির প্রশ্ন (কোন নাম public) সঙ্গে আনে। ভালো নকশা তিনটির উত্তর স্পষ্ট লিখে দেয়।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। প্রতিটি আউটপুট সত্যিকারের Clang 22.1.8 বা CPython 3.14.4-এ চালিয়ে মেলানো।

  1. নকশা ও বাস্তবায়ন — Haat-এ ref parameter-এর যাচাই: Haat-এর বর্ধিত রূপে fn add_fee(ref total: Int, fee: Int) লেখা যাবে। একটি function লিখুন যা একটি call-এর argument-গুলো যাচাই করে: ref জায়গায় argument অবশ্যই একটি var নাম; let, parameter, literal বা অন্য expression হলে error; আর একই call-এ একই নাম দুটি ref-এ গেলে error. Error বার্তা Haat-এর রীতিতে ইংরেজিতে।

    লেখকের যন্ত্রে চালানো সমাধান (symbol table-কে সরল dict ধরে):

    def check_ref_args(params, args, kinds):
        """params: [(name, is_ref)], args: AST-like tuples, kinds: name -> 'var'|'let'|'param'"""
        errors, seen = [], set()
        for (pname, is_ref), arg in zip(params, args):
            if not is_ref:
                continue
            if arg[0] != "var":
                errors.append(f"argument for 'ref {pname}' must be a variable")
            elif kinds.get(arg[1]) != "var":
                errors.append(f"cannot pass '{arg[1]}' by ref: it is not declared with 'var'")
            elif arg[1] in seen:
                errors.append(f"'{arg[1]}' is passed by ref more than once")
            else:
                seen.add(arg[1])
        return errors
    
    ps = [("x", True), ("y", True), ("fee", False)]
    kinds = {"total": "var", "rate": "let", "n": "param"}
    print(check_ref_args(ps, [("var", "total"), ("var", "total"), ("num", 60)], kinds))
    print(check_ref_args(ps, [("var", "rate"), ("num", 1), ("num", 60)], kinds))
    print(check_ref_args(ps, [("var", "total"), ("var", "n"), ("var", "rate")], kinds))
    
    ["'total' is passed by ref more than once"]
    ["cannot pass 'rate' by ref: it is not declared with 'var'", "argument for 'ref y' must be a variable"]
    ["cannot pass 'n' by ref: it is not declared with 'var'"]

    নকশার যুক্তি: let আর parameter অপরিবর্তনীয় (নকশা-সিদ্ধান্ত ১৯), তাই তাদের ঘর লেখার জন্য দেওয়া যায় না; আর “দুবার নয়” নিয়মটি অংশ ৪-এর swap_add(p, p)-এর ভুল compile-এর সময়েই আটকায়, Swift-এর exclusivity-র মতো। শেষ call-এ rate সাধারণ (by value) parameter-এ গেছে, তাই সেটি বৈধ। সীমা: Haat v1-এ array নেই বলে এখানে a[i]-এর প্রশ্ন ওঠে না; বর্ধিত রূপে array এলে i আর j সমান কি না compile-এর সময় সাধারণত জানা যায় না, তখন চলার সময়ে পরীক্ষা লাগবে। Closure-এর ভেতর থেকে ধরা var ref দিয়ে গেলেও একটি alias থেকে যায়, যা এই সরল পরীক্ষা ধরে না।

  2. আউটপুট অনুমান করুন — swap(i, a[i]): শুরুতে i = 0, a = [1, 9]. Function swap(MODE x, MODE y) { let t = x; x = y; y = t; }, ডাক swap(i, a[i]). By value, by reference, by value-result (ঠিকানা call-এর সময়ে, copy back বাঁ থেকে ডানে) আর by name-এ i আর a কী হবে?

    By value: শুধু কপি অদলবদল, i = 0, a = [1, 9]. By reference: x ≡ i, y ≡ a[0] (call-এর সময় i = 0). t = 0; i = a[0] = 1; a[0] = 0. ফল i = 1, a = [0, 9]: সঠিক swap. By value-result: x = 0, y = 1, ঠিকানা i আর a[0]. ভেতরে x = 1, y = 0; copy back: i = 1, a[0] = 0. ফল একই, i = 1, a = [0, 9]. By name: t = i = 0; x = y মানে i = a[i] = a[0] = 1; y = t মানে a[i] = 0, কিন্তু এখন i = 1, তাই a[1] = 0. ফল i = 1, a = [1, 0]: ভুল ঘর বদলেছে। লেখকের যন্ত্রে simulator-এর বহু-parameter রূপ চালিয়ে মেলানো:

    swap value         {'i': 0, 'a': [1, 9]}
    swap reference     {'i': 1, 'a': [0, 9]}
    swap value-result  {'i': 1, 'a': [0, 9]}
    swap name          {'i': 1, 'a': [1, 0]}

    এটি সেই বিখ্যাত ফল যে call by name-এ একটি সাধারণ swap লেখা যায় না। আর একটি সূক্ষ্মতা: value-result-এ ঠিকানা যদি ফেরার সময় নেওয়া হতো আর বাঁ থেকে ডানে copy back হতো, তাহলে আগে i = 1 লেখা হয়, তারপর a[i] মানে a[1] = 0, ফল a = [1, 0], by name-এর মতো ভুল। একই simulator-এ এই রূপও চালিয়ে মেলানো।

  3. ভুল খুঁজুন: বাজারঘরের একটি C++20 function সবচেয়ে বড় তিনটি অর্ডার ফেরত দিতে চায়। কী ভুল, compiler কী বলে, আর দুটি সমাধান দিন।
    #include <algorithm>
    #include <vector>
    const std::vector<int> &top3(std::vector<int> v) {
        std::sort(v.rbegin(), v.rend());
        v.resize(3);
        return v;
    }

    v by value নেওয়া একটি parameter, অর্থাৎ function-এর নিজের local কপি (সাধারণত এই function-এর frame-এর সঙ্গে বাঁধা)। Function শেষ হলে v ধ্বংস হয়, অথচ ফেরত দেওয়া হচ্ছে তার reference: ডাকা-পক্ষ একটি dangling reference পায়, আর তা ব্যবহার করা undefined behavior. সত্যিকারের run-এ Clang সরাসরি সতর্ক করেছে:

    ~/haat $ zig c++ -std=c++20 -Wall -Wextra -c top3.cpp
    top3.cpp:6:12: warning: reference to stack memory associated with parameter 'v' returned [-Wreturn-stack-address]

    সমাধান: (১) ফেরত type std::vector<int> করুন, by value; C++-এ local বা parameter ফেরত দিলে কপির বদলে move হয় (ফেরার সময় স্বয়ংক্রিয়ভাবে), তাই খরচ কম। (২) ডাকা-পক্ষের vector-ই বদলাতে চাইলে void top3(std::vector<int> &v), অর্থাৎ in-out parameter; তবে তখন ডাকা-পক্ষের মূল তালিকা ছোট হয়ে যায়, যা হয়তো চান না। শিক্ষা: parameter-এর lifetime function-এর call-এর সঙ্গে বাঁধা, তাই parameter-এর reference ফেরত দেওয়া local-এর reference ফেরত দেওয়ার মতোই ভুল (পর্ব ১৬ আর ২৩)।

  4. প্রমাণ — aliasing না থাকলে value-result = reference: ধরুন f-এর একটি in-out parameter x, দেহ শুধু assignment-এর একটি তালিকা, actual parameter-এর ঘর ℓ, আর দেহ x ছাড়া অন্য কোনো পথে ℓ পড়ে বা লেখে না (aliasing নেই), আর কোনো expression ঘর ℓ′ জানে না। প্রমাণ করুন: Call-R আর Call-VR শেষে একই store দেয়।

    প্রমাণের রূপরেখা, দেহের statement-এর সংখ্যার ওপর induction (পদ্ধতিটি Discrete Mathematics কোর্সের পর্ব ১০-এ)। R-এর store-কে σR, VR-এর store-কে σV বলি। দাবি (invariant) I: প্রতিটি statement-এর পরে σV(ℓ′) = σR(ℓ), আর ℓ ও ℓ′ ছাড়া প্রতিটি ঘর m-এ σV(m) = σR(m); আর σV(ℓ) = শুরুর মান।

    1. শুরু: Call-VR σV = σ[ℓ′ ↦ σ(ℓ)], Call-R σR = σ. তাই σV(ℓ′) = σ(ℓ) = σR(ℓ), বাকি ঘর এক। I সত্য।
    2. এক ধাপ: statement t = e. R-এ x-এর ঘর ℓ, VR-এ ℓ′; aliasing নেই বলে এ দুটি ছাড়া কোনো নাম ℓ বা ℓ′-এ পৌঁছায় না। তাই e-এর প্রতিটি পড়া দুই store-এ “অনুরূপ” ঘর পড়ে (x হলে ℓ বনাম ℓ′, অন্যথায় একই ঘর), আর I অনুযায়ী মানগুলো সমান, ফলে e-এর মান সমান।
    3. লেখার ঘরও অনুরূপ: t = x হলে R লেখে ℓ-এ, VR লেখে ℓ′-এ; অন্য নাম হলে দুটিই একই ঘর m-এ (m ≠ ℓ, ℓ′)। দুই ক্ষেত্রেই I বজায় থাকে, আর VR-এ ℓ কেউ ছোঁয়নি।
    4. শেষ: Call-VR copy back করে: σV[ℓ ↦ σV(ℓ′)] = σV[ℓ ↦ σR(ℓ)]. এখন ℓ-এ দুটিই সমান, আর বাকি সব ঘরও সমান। ℓ′ শুধু callee-র নিজের ঘর, ফেরার পরে কেউ তা দেখে না। তাই দৃশ্যমান store এক। ∎

    অনুমানটি কোথায় লাগল, লক্ষ করুন: ধাপ ২ আর ৩-এ “ℓ-এ অন্য কোনো পথ নেই”. অংশ ৩-এর f(g)-এ ঠিক এটি ভাঙে (দেহের g = g * 10 সরাসরি ℓ-এ লেখে), আর তাই সেখানে 60 বনাম 6. এই প্রমাণই ব্যাখ্যা করে কেন Swift বা Ada aliasing আটকালে বাস্তবায়ন বেছে নিতে স্বাধীন।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমCall by value-result-এ f(a[i]) ডাকা হলো (ঠিকানা call-এর সময়ে)। ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. ডাকা-পক্ষ a[i]-এর ঘরের ঠিকানা হিসাব করে মনে রাখে
  2. সেই ঘরের মান callee-র নতুন ঘরে কপি হয়
  3. Callee-র দেহ শুধু নিজের ঘরে পড়ে আর লেখে
  4. ফেরার সময় নিজের ঘরের শেষ মান মনে রাখা ঠিকানায় লেখা হয়
  5. ডাকা-পক্ষ call-এর পরের statement থেকে চলতে থাকে

শুরুতে g = 2. Function f(x) { x = x + 1; g = g * 10; x = x * 2; }, তারপর f(g). Call by reference হলে শেষে g কত?

  • 20
  • 6
  • 60
  • 30

শুরুতে g = 2. Function f(x) { x = x + 1; g = g * 10; x = x * 2; }, তারপর f(g). Call by value-result (copy-in copy-out) হলে শেষে g কত?

  • 6
  • 20
  • 60
  • 26

Java 21-এ static void swap(Integer a, Integer b) { Integer t = a; a = b; b = t; } লিখে swap(x, y) ডাকলে x আর y অদলবদল হয় না। কেন?

  • Integer অপরিবর্তনীয় বলে, mutable class হলে কাজ করত
  • Java parameter by value পাঠায়; a আর b শুধু reference-এর কপি, তাই তাদের সরানো x আর y-কে ছোঁয় না
  • Parameter-এ assignment Java-তে compile error
  • Integer cache-এর কারণে a আর b একই object

Python 3.14-এ def add(x, acc=[]): acc.append(x); return acc. তারপর add(1) ডেকে print(add(2)) কী ছাপবে?

  • [2]
  • [1]
  • TypeError
  • [1, 2]

C++20-এ একটি ৬৪ byte-এর Order object function-কে দিতে হবে। Function শুধু পড়বে, বদলাবে না, আর কপির খরচও চান না। কোন parameter type সবচেয়ে উপযুক্ত?

  • Order o
  • Order &o
  • const Order &o
  • Order &&o

Haat program: fn bump(n: Int) -> Int { n = n + 1; return n; } print(bump(5)); — reference বাস্তবায়নে কী হবে?

  • 6 ছাপে
  • Static error: cannot assign to parameter 'n'
  • 5 ছাপে
  • Runtime error

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Mode বনাম মডেল: in, out, in-out বলে তথ্য কোন দিকে যায়; value, result, value-result, reference, sharing আর name বলে কীভাবে।
  2. নিয়মে পার্থক্য: value নতুন ঘরে কপি নেয়; reference ডাকা-পক্ষের ঘরেই বাঁধে; value-result কপি নিয়ে ফেরার সময় call-এর সময়ের ঠিকানায় লিখে দেয়; name প্রতিবার expression নতুন করে হিসাব করে।
  3. Aliasing সব পার্থক্যের উৎস: f(g)-এ 20 / 60 / 6 / 60; swap_add(p, p) 0 দেয়; value-result-এ copy back-এর ক্রম উত্তর বদলায়। Aliasing না থাকলে value-result আর reference এক।
  4. Sharing = reference-এর মান by value: Python, Java, JavaScript-এ mutation দেখা যায়, rebinding নয়। বড় object-এ C++ const T& কপি এড়ায়; Rust &, &mut আর move দিয়ে উদ্দেশ্য type-এ লেখে।
  5. Haat v1: সব parameter by value আর অপরিবর্তনীয়; by-reference দরকার হলে get/set closure, যা আসলে thunk-এর লেখার-দিকসহ রূপ।

পরের পর্বে: এই পর্বে দেখলেন কী যায়; পর্ব ৩০-এ (Subprogram-এর বাস্তবায়ন) দেখবেন কোথায় যায়: activation record-এর ঘর, caller আর callee-র দায়িত্ব, static আর dynamic link, আর Haat VM-এর frame-এ parameter কোন slot-এ বসে।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান