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

Pointer আর reference — aliasing, dangling pointer আর null

Pointers and References — Aliasing, Dangling Pointers and Null

Taught in Bangla, this lesson defines pointers with environment and store and applies &, * and pointer arithmetic, where p + 2 on an int moves 8 bytes in a real Clang 22.1.8 run. It separates C++ references, object references in Java, Python and JavaScript, and Rust borrows, and real -O2 assembly shows aliasing keeping a load that restrict removes. Python simulations cover a toy heap's use-after-free and null checks, and a real C++ run shows unique_ptr and shared_ptr ownership.

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

  • Pointer-কে environment আর store-এর ভাষায় সংজ্ঞায়িত করা, আর &, * ও pointer arithmetic-এর নিয়ম ঠিকানা হিসাব করে প্রয়োগ করা
  • C pointer, C++ reference আর Java/Python/JavaScript-এর object reference-এর পার্থক্য একটি টেবিলে বলা
  • Aliasing কেন compiler-এর optimization আটকায়, আর restrict কী প্রতিশ্রুতি দেয়, সত্যিকারের assembly দেখে বোঝা
  • Use-after-free কীভাবে তৈরি হয়, কেন বিপজ্জনক, আর ভাষা, compiler ও runtime কীভাবে তা ঠেকায়
  • Null-এর বিকল্প (nullable type, Option) আর smart pointer-এর মালিকানা-নিয়ম ব্যাখ্যা করা

১ · Pointer মানে ঠিকানা — নাম, ঘর আর ঠিকানা

বাজারঘরের ডেলিভারি কর্মী রফিকের হাতে একটি চিরকুট: “বাড়ি ১২, রোড ৪, মিরপুর”. চিরকুটটি পার্সেল নয়, বাড়িও নয়; এটি শুধু বলে বাড়িটি কোথায়। চিরকুটের ফটোকপি করলে বাড়ি দুটি হয় না, একই বাড়ির দুটি চিরকুট হয়। আর বাড়িটি ভেঙে সেখানে নতুন পরিবার এলে পুরোনো চিরকুট রফিককে ঠিক সেই ঠিকানাতেই নিয়ে যাবে, কিন্তু দরজা খুলবে অন্য কেউ। এই পর্বের তিনটি বড় ধারণা এই এক উপমায় আছে: pointer (চিরকুট), aliasing (দুটি চিরকুট, এক বাড়ি) আর dangling pointer (বাড়ি বদলে গেছে, চিরকুট রয়ে গেছে)।

পর্ব ১৪-এ (নাম, variable আর binding) দেখেছেন, একটি নাম থেকে মান পর্যন্ত পথ দুই ধাপের: environment ρ নাম থেকে ঘর দেয়, আর store σ ঘর থেকে মান। Pointer এই ছবিতে একটিই নতুন জিনিস যোগ করে: ঘরের পরিচয় নিজেই একটি মান হতে পারে। তখন সেই মান variable-এ রাখা, function-এ পাঠানো আর তুলনা করা যায়। ঘরের পরিচয় বাস্তবে একটি সংখ্যা, যাকে বলে memory address.

সংজ্ঞা ২৩.১ — pointer, address-of আর dereference

ধরুন ℓ একটি ঘরের পরিচয় (location). Pointer মান হলো এমন একটি ℓ. দুটি operator আছে:

Address-of &x = ρ(x): নামের ঘরটি নিজেই ফল, ভেতরের মান নয়।

Dereference *e: আগে e হিসাব করে ঘর ℓ পাওয়া যায়। ডান দিকে (পড়ার জায়গায়) *e-এর মান σ(ℓ); বাঁ দিকে (লেখার জায়গায়) *e = v store বদলায়: σ′ = σ[ℓ ↦ v].

অর্থাৎ *e একটি l-value (একটি ঘর), আর &x একটি r-value (একটি মান, যার মধ্যে ঘরের পরিচয়)।

Type-এর দিক থেকে নিয়ম দুটি এমন (Γ ⊢ e : τ পড়ুন “পরিবেশ Γ-তে e-এর type τ”; T* মানে “T-এর ঘরের ঠিকানা”). দাগের ওপরের শর্ত সত্য হলে নিচের সিদ্ধান্ত সত্য:

Γ ⊢ x : T    x একটি l-value
Γ ⊢ &x : T*
(Addr)
Γ ⊢ e : T*
Γ ⊢ *e : T
(Deref)

লক্ষ করুন, (Deref) নিয়ম শুধু type দেখে; e আসলে কোনো জীবিত ঘর দেখায় কি না, তা বলে না। এই ফাঁকেই এই পর্বের সব বিপদ লুকিয়ে আছে: null, dangling আর সীমার বাইরের ঠিকানা সবাই T* type পায়, কিন্তু σ-তে তাদের ঘর নেই। C-র type system এই ফাঁক বন্ধ করে না; পরের অংশগুলোতে দেখবেন অন্য ভাষাগুলো কীভাবে করে।

ছবি ২৩.১ — pointer, C++ reference আর object reference

ঠিকানাগুলো উদাহরণ; আসল ঠিকানা প্রতিবার চালালে বদলাতে পারে।

Pointer p holds the address of total; C++ reference r is another name for total; two Java-style references point to one heap object C / C++: ঠিকানা দেখা যায় total · 0x1000 936 p · 0x1008 0x1000 int& r = total → একই ঘর Java / Python / JS: তীর cart basket Order total: 936 ঠিকানা লুকানো; GC object সরাতে পারে
ছবি ২৩.১ — ওপরে C-র pointer p নিজেই একটি ঘর (ঠিকানা 0x1008), যার মান আরেকটি ঘরের ঠিকানা; C++ reference r-এর সাধারণত নিজের কোনো দেখা-যায় এমন ঘর নেই, এটি total-এরই দ্বিতীয় নাম। নিচে managed ভাষার দুটি reference একই heap object দেখায় (aliasing), কিন্তু প্রোগ্রামার ঠিকানা পড়তে বা বদলাতে পারেন না।

Haat v1-এ এর কোনোটিই নেই: Int, Bool আর Str মান হিসেবে কপি হয়, আর ঠিকানা নেওয়ার কোনো operator নেই। সত্যিকারের run-এ & লিখলে lexer-ই থামে, কারণ reference বাস্তবায়নে একা & একটি অচেনা অক্ষর (নকশা-সিদ্ধান্ত ২):

var total = 936;
let p = &total;
~/haat $ python haat.py check amp.haat
2:9: error: unexpected character '&'

তাহলে pointer শিখব কেন? কারণ Haat-এর বাস্তবায়ন যে ভাষায় চলে (CPython), তার ভেতরে সবই pointer; পর্ব ৫৯-এর VM-এর operand stack আর পর্ব ৭৫-এর garbage collector pointer ছাড়া বানানো যায় না; আর পর্ব ৭২-এ Haat থেকে RISC-V assembly বানানোর সময় প্রতিটি variable একটি ঠিকানা হয়ে যাবে। Pointer ভাষার নকশায় না থাকলেও বাস্তবায়নে থাকবেই।

২ · Pointer arithmetic — array-র ওপর দিয়ে হাঁটা

C-তে pointer-এর সঙ্গে পূর্ণসংখ্যা যোগ করা যায়। এটি C-র সবচেয়ে শক্তিশালী আর সবচেয়ে বিপজ্জনক বৈশিষ্ট্যগুলোর একটি। নিয়মটি একটি বাক্যে: pointer arithmetic-এ একক হলো ঘর, byte নয়।

নিয়ম ২৩.২ — pointer-এর যোগ আর বিয়োগ (C17 §6.5.6)

p যদি n ঘরের একটি array-র i নম্বর ঘর দেখায়, আর প্রতিটি ঘরের type T, তাহলে p + k দেখায় i + k নম্বর ঘর, যার ঠিকানা = ঠিকানা(p) + k × sizeof(T). এটি বৈধ শুধু যদি 0 ≤ i + k ≤ n; i + k = n মানে “শেষের ঠিক পরের ঘর” (one past the end), যার ঠিকানা হিসাব করা যায় কিন্তু * চালানো যায় না। একই array-র দুটি pointer-এর বিয়োগ q - p = (ঠিকানা(q) − ঠিকানা(p)) / sizeof(T), অর্থাৎ ঘরের সংখ্যা। আর p[k] সংজ্ঞা অনুযায়ী *(p + k).

বিশ্ববিদ্যালয় আর চাকরির পরীক্ষায় এই সূত্রটি খুব প্রচলিত: “int a[10]-এর base address 2000, int ৪ byte হলে a + 3-এর ঠিকানা কত?” উত্তর 2000 + 3 × 4 = 2012. নিচের stepper বাজারঘরের এক দিনের চারটি অর্ডারের পরিমাণের ওপর দিয়ে হাঁটে। Array শুরু হয়েছে ধরে নেওয়া ঠিকানা 0x1000-এ (দেখানোর সুবিধার জন্য); বাকি সব সংখ্যা নিচের সত্যিকারের run থেকে মেলানো।

1int qty[4] = {2, 5, 1, 3};2int *p = qty;3int *q = p + 2;4printf("%td", q - p);5int sum = 0;6for (int *it = qty; it != qty + 4; it++)7    sum += *it;
এই ধাপের পরে
qty @ 0x1000
p
q
it, *it
sum
  1. Array. চারটি int পাশাপাশি, প্রতিটি ৪ byte: মোট ১৬ byte, 0x1000 থেকে 0x100F পর্যন্ত।
  2. Decay. int *p = qty;: array-র নাম এখানে প্রথম ঘরের ঠিকানায় বদলে যায় (array-to-pointer conversion). p = 0x1000, *p = 2.
  3. যোগ। p + 2 = 0x1000 + 2 × 4 = 0x1008, অর্থাৎ তৃতীয় ঘর; *q = 1. Compiler গুণটি নিজেই করে, কারণ সে p-এর type int * জানে।
  4. বিয়োগ। q - p = (0x1008 − 0x1000) / 4 = 2: byte-এ দূরত্ব ৮, ঘরে দূরত্ব ২. ফলের type ptrdiff_t, তাই %td.
  5. Loop, প্রথম ঘর। it = 0x1000, *it = 2, sum = 2. এখানে index নেই; pointer নিজেই এগোয়, পুরোনো C কোডে এটি খুব প্রচলিত ধরন।
  6. দ্বিতীয় ঘর। it++ = ৪ byte এগোনো: 0x1004, *it = 5, sum = 7.
  7. তৃতীয় ঘর। 0x1008, *it = 1, sum = 8.
  8. চতুর্থ ঘর। 0x100C, *it = 3, sum = 11.
  9. শেষের পরের ঘর। it = 0x1010 = qty + 4: এই ঠিকানা হিসাব করা আর তুলনা করা বৈধ, তাই loop থামে। কিন্তু এখানে *it পড়লে undefined behavior; !=-এর বদলে <= লিখলে ঠিক এই ভুলটি হতো।

এই পর্বের সব C আর C++ run সত্যিকারের: PyPI-র ziglang 0.17.1 (MIT licence), যার ভেতরে Clang 22.1.8; এখানে zig মানে python -m ziglang. Wandbox এই সময়ে HTTP 500 দিচ্ছিল, তাই C কোড পাতায় চালানোর ব্লক হিসেবে রাখা হয়নি; আউটপুট লেখকের যন্ত্রে নেওয়া।

#include <stdio.h>
#include <stddef.h>

int main(void) {
    int qty[4] = {2, 5, 1, 3};          /* orders of one day */
    int *p = qty;                       /* array decays to &qty[0] */
    int *q = p + 2;                     /* moves 2 elements, not 2 bytes */
    printf("sizeof(int) = %zu\n", sizeof(int));
    printf("bytes from p to q = %td\n", (char *)q - (char *)p);
    printf("elements from p to q = %td\n", q - p);
    printf("*q = %d, p[2] = %d, *(qty + 2) = %d, 2[qty] = %d\n",
           *q, p[2], *(qty + 2), 2[qty]);
    int sum = 0;
    for (int *it = qty; it != qty + 4; it++)   /* qty + 4: one past the end */
        sum += *it;
    printf("sum = %d\n", sum);
    return 0;
}
~/haat $ zig cc -std=c17 -Wall -Wextra arith.c -o arith.exe && ./arith.exe
sizeof(int) = 4
bytes from p to q = 8
elements from p to q = 2
*q = 1, p[2] = 1, *(qty + 2) = 1, 2[qty] = 1
sum = 11

সত্যিকারের run, কোনো warning ছাড়া। (char *)-এ রূপান্তর করে বিয়োগ করলে একক হয় byte (কারণ sizeof(char) = 1), তাই 8; int * হিসেবে বিয়োগ করলে একক ঘর, তাই 2. চতুর্থ লাইনের শেষ অংশটি একটি পুরোনো ধাঁধা: 2[qty] বৈধ C, কারণ a[b] সংজ্ঞা অনুযায়ী *(a + b), আর যোগ বিনিময়যোগ্য। এটি দেখায় যে C-তে array indexing আলাদা কোনো ধারণা নয়, pointer arithmetic-এর একটি সংক্ষিপ্ত লেখা মাত্র। Array-র পূর্ণ আলোচনা পর্ব ২২-এ (Composite type), আর C-র দিক থেকে হাতে-কলমে C কোর্সের পর্ব ১৭-এ।

Pointer arithmetic থেকেই C-র বহু শক্তি আসে: একটি buffer-এর ওপর দ্রুত হাঁটা, struct-এর ভেতরের field-এর ঠিকানা, memory allocator লেখা। কিন্তু নিয়ম ২৩.২-এর “শুধু যদি 0 ≤ i + k ≤ n” শর্তটি compiler যাচাই করে না, চলার সময়ও কেউ করে না। এজন্য পরের প্রজন্মের ভাষাগুলো এটি সরিয়ে দিয়েছে বা আটকে রেখেছে। Java আর JavaScript-এ pointer-এর সঙ্গে সংখ্যা যোগের কোনো উপায়ই নেই। Go-তে pointer আছে কিন্তু arithmetic নেই, শুধু unsafe package দিয়ে সম্ভব। Rust-এ নিরাপদ reference-এ arithmetic নেই; raw pointer-এর ওপর তা করা যায় শুধু unsafe block-এ। সবার উত্তর একই: array-তে হাঁটার কাজটি index আর bounds check বা iterator দিয়ে করুন, ঠিকানা-গণিত দিয়ে নয়।

৩ · Reference — একই শব্দ, তিনটি আলাদা জিনিস

“Reference” শব্দটি বিভিন্ন ভাষায় তিনটি আলাদা ধারণা বোঝায়, আর এখান থেকেই প্রচুর বিভ্রান্তি আসে। প্রতিটি আলাদা করে দেখি।

এক, C++-এর reference (int& r = total;): এটি একটি দ্বিতীয় নাম। তৈরির সময়েই একটি জীবিত object-এর সঙ্গে বাঁধতে হয়, পরে আর অন্য object-এ সরানো যায় না, আর null reference বৈধ C++-এ তৈরিই করা যায় না। r = 5; লিখলে total বদলায়, r অন্য কোথাও যায় না। বাস্তবায়নে compiler প্রায়ই reference-কে একটি pointer দিয়েই রাখে, কিন্তু ভাষার স্তরে আপনি সেই pointer ছুঁতে পারেন না। বিস্তারিত C++ কোর্সের পর্ব ১০-এ।

দুই, managed ভাষার reference (Java, Python, JavaScript, C#): এখানে object সবসময় heap-এ, আর variable-এ থাকে object-এর দিকে একটি তীর। তীরটি একটি সাধারণ মানের মতো আচরণ করে: assignment-এ তীরটিই কপি হয়, object নয়। Function-এ পাঠালেও তা-ই; এই নিয়মকে বলে call by sharing, নামটি Barbara Liskov-এর CLU ভাষার (১৯৭০-এর দশক) সময় থেকে প্রচলিত বলে জানা যায়। ফল: function object-এর ভেতর বদলালে ডাকা-পক্ষ দেখে, কিন্তু parameter-কে নতুন object-এ সরালে ডাকা-পক্ষের কিছুই হয় না। Parameter passing-এর পুরো তুলনা পর্ব ২৯-এ। JavaScript-এ নিজে দেখুন:

function addFee(order) {
  order.total = order.total + 60;   // changes the shared object
  order = { total: 0 };             // rebinds only the local name
  return order.total;
}
const a = { total: 936 };
const b = a;                        // second reference, same object
console.log("addFee returned", addFee(b));
console.log("a.total =", a.total, "| a === b:", a === b);

let n = 936;
let m = n;                          // numbers are copied
m = m + 60;
console.log("n =", n, "| m =", m);

const c = { total: 996 };
console.log("same contents, a === c:", a === c, "| c.total:", c.total);

let found = null;                   // "no order found"
try {
  console.log(found.total);
} catch (e) {
  console.log(e.constructor.name + ":", e.message);
}
console.log("optional chaining:", found?.total, "| with default:", found?.total ?? 0);
console.log("WeakRef available:", typeof WeakRef === "function");

আসল আউটপুট (ব্রাউজারের JavaScript, Chromium-ভিত্তিক Edge; Node 24-এও হুবহু এক):

addFee returned 0
a.total = 996 | a === b: true
n = 936 | m = 996
same contents, a === c: false | c.total: 996
TypeError: Cannot read properties of null (reading 'total')
optional chaining: undefined | with default: 0
WeakRef available: true

প্রথম দুই লাইন: addFee object-এ 60 যোগ করেছে, আর সেটি a দিয়েও দেখা যায় (a, b আর order তিনটি নাম, একটি object). তারপর order = {total: 0} শুধু function-এর ভেতরের নামটি সরিয়েছে, তাই ফেরত 0 কিন্তু a.total 996. তৃতীয় লাইন: number-এর মতো primitive মান কপি হয়। চতুর্থ লাইন: === object-এর বেলায় পরিচয় (identity) তুলনা করে, ভেতরের মান নয়: a আর c-তে একই 996, তবু দুটি আলাদা object. শেষ তিন লাইন: null-এর ভেতরে ঢুকলে TypeError (বার্তার শব্দ browser-ভেদে আলাদা হতে পারে); ?. আর ?? null-কে নিরাপদে সামলানোর ছোট পথ, যার কথা অংশ ৬-এ। WeakRef এমন একটি reference যা object-কে বাঁচিয়ে রাখে না (ECMAScript 2021); এই browser-এ আছে, তবে কখন object মুছবে তা অনিশ্চিত, তাই সাধারণ কোডে খুব কম ব্যবহার করা উচিত।

তিন, Rust-এর reference (&T আর &mut T): দেখতে C++-এর মতো, কিন্তু compiler প্রতিটি reference কতক্ষণ বৈধ (lifetime) তা compile-এর সময় যাচাই করে, আর একটি নিয়ম বাধ্য করে: একই সময়ে হয় অনেকগুলো পড়ার reference, নয়তো একটিমাত্র বদলানোর reference. এর পুরো গল্প পর্ব ৭৬-এ (Memory safety আর ownership).

বৈশিষ্ট্যC pointerC++ referenceJava/Python/JS referenceRust &T
নিজে একটি মান, কপি করা যায়হ্যাঁনা, নাম মাত্রহ্যাঁ (তীরটি কপি হয়)হ্যাঁ (&T কপি হয়)
Null হতে পারেহ্যাঁনাহ্যাঁ (null/None)না; দরকারে Option<&T>
অন্য object-এ সরানো যায়হ্যাঁনাহ্যাঁ (নতুন assignment)নাম mut হলে হ্যাঁ
ঠিকানা-গণিতহ্যাঁনানানা (শুধু unsafe-এ raw pointer)
Dangling সম্ভবহ্যাঁহ্যাঁনা (GC বাঁচিয়ে রাখে)নিরাপদ কোডে না
Object কে মোছেপ্রোগ্রামারপ্রোগ্রামার বা smart pointerGarbage collectorOwnership-এর নিয়ম

৪ · Aliasing — দুই চিরকুট, এক বাড়ি, আর optimizer-এর দ্বিধা

পর্ব ১৪-এ aliasing-এর সংজ্ঞা দেখেছেন: দুটি আলাদা নাম, কিন্তু ρ(x) = ρ(y). Pointer এলে aliasing আর নামের মধ্যে আটকে থাকে না: দুটি expression *a আর *b একই ঘর বোঝাতে পারে, আর সেটি নির্ভর করে চলার সময় a আর b-তে কী আছে তার ওপর। পর্ব ০৭-এ (Imperative আর procedural programming) একটি প্রশ্ন রেখে আসা হয়েছিল: নিচের function কি সবসময় 1 ফেরত দেয়? ধাপে ধাপে দেখুন।

1int set_two(int *a, int *b) {2    *a = 1;3    *b = 2;4    return *a;5}6set_two(&x, &y);   /* two boxes */7set_two(&x, &x);   /* one box   */
এই ধাপের পরে
a →, b →
x
y
ফেরত
  1. দুটি আলাদা ঘর। প্রথম ডাকে a দেখায় x-কে, b দেখায় y-কে। দুটিতেই 0.
  2. *a = 1. x = 1.
  3. *b = 2. y = 2; x অক্ষত।
  4. return *a. x পড়া হয়: 1. এখানে মনে হয় compiler সোজা 1 লিখে দিলেই পারত।
  5. একই ঘর। দ্বিতীয় ডাকে a আর b দুটিই x-কে দেখায়: *a আর *b এখন একে অপরের alias.
  6. *a = 1. x = 1.
  7. *b = 2. এবার লেখা হয় সেই x-এই: x = 2. a দিয়ে দেখলেও এখন 2.
  8. return *a. ফেরত 2, 1 নয়। তাই restrict ছাড়া compiler return *a-কে return 1 বানাতে পারে না; এটি অবৈধ optimization হতো। সত্যিকারের run: same box: 2.
  9. প্রতিশ্রুতি ভাঙলে। একই function-এ int *restrict a, int *restrict b লিখে &x, &x পাঠালে আচরণ undefined; Clang 22.1.8-এর -O2 build ফেরত দিয়েছে 1, অথচ x-এ তখন 2 (নিচের সত্যিকারের run).

Clang নিজে কী করে, assembly-তে দেখা যাক। একই ফাইলে দুটি function: একটি সাধারণ, একটিতে C99-এর restrict.

int set_two(int *a, int *b) {
    *a = 1;
    *b = 2;
    return *a;            /* 1 or 2? depends on aliasing */
}

int set_two_r(int *restrict a, int *restrict b) {
    *a = 1;
    *b = 2;
    return *a;            /* promise: a and b never alias */
}
~/haat $ zig cc -std=c17 -O2 -g0 -S --target=x86_64-linux-musl \
      -fno-asynchronous-unwind-tables -fomit-frame-pointer alias.c -o alias.s
~/haat $ cat alias.s        # trimmed: .cfi lines and directives removed
set_two:
        movl    $1, (%rdi)
        movl    $2, (%rsi)
        movl    (%rdi), %eax
        retq
set_two_r:
        movl    $1, (%rdi)
        movl    $2, (%rsi)
        movl    $1, %eax
        retq

সত্যিকারের run, Clang 22.1.8, x86-64. এই target-এর calling convention-এ প্রথম argument %rdi-তে, দ্বিতীয়টি %rsi-তে, ফেরত মান %eax-এ (বিস্তারিত পর্ব ৭১-এ)। দুটি function-এর প্রথম দুই নির্দেশ এক: দুটি store. পার্থক্য তৃতীয় লাইনে। set_two মেমরি থেকে আবার পড়ে (movl (%rdi), %eax), কারণ মাঝের store a-র ঘরটিই বদলে থাকতে পারে। set_two_r পড়াটাই বাদ দিয়েছে, সরাসরি movl $1, %eax: restrict-এর প্রতিশ্রুতি ধরে নিয়ে compiler জানে b দিয়ে লেখা a-র ঘর ছোঁয় না। একটি load কম মনে হয় ছোট ব্যাপার, কিন্তু loop-এর ভেতরে এটিই ঠিক করে compiler মান register-এ রাখতে পারবে কি না, বা vector নির্দেশ ব্যবহার করতে পারবে কি না।

প্রতিশ্রুতি ভাঙলে কী হয়, একই যন্ত্রে দুই optimization level-এ সত্যিকারের run (একটি function-এ restrict রেখে set_two_r(&x, &x) ডাকা; inlining আটকাতে noinline):

~/haat $ zig cc -std=c17 -Wall -Wextra -O0 -fno-sanitize=undefined broken.c -o b0.exe && ./b0.exe
returned 2, x is now 2
~/haat $ zig cc -std=c17 -Wall -Wextra -O2 -fno-sanitize=undefined broken.c -o b2.exe && ./b2.exe
returned 1, x is now 2

কোনো warning নেই, আর দুটি build দুটি আলাদা উত্তর দিয়েছে। এটি undefined behavior-এর চেনা চেহারা: ভাষা কোনো ফলের নিশ্চয়তা দেয় না, তাই “-O0-তে ঠিক ছিল” কোনো প্রমাণ নয়। restrict হলো প্রোগ্রামারের দেওয়া প্রতিশ্রুতি, compiler তা যাচাই করে না।

Compiler-এর ভেতরে — alias জেনে store-to-load forwarding

Optimizer-এর যে অংশটি উপরের সিদ্ধান্ত নেয়, তার একটি ছোট রূপ নিজে বানানো যায়। নিচের কোড তিন নির্দেশের একটি IR নেয়, আর store-to-load forwarding চালায়: আগে কোনো ঘরে যা লেখা হয়েছে তা মনে রাখে, আর পরে সেই ঘর পড়ার নির্দেশকে সরাসরি সেই মান দিয়ে বদলায়। কিন্তু প্রতিটি store-এর সময় তাকে প্রশ্ন করতে হয়: “এই লেখা কি অন্য কোনো মনে-রাখা ঘর বদলে দিতে পারে?” সেই প্রশ্নের উত্তর দেয় may_alias. বাস্তব compiler-এ এই কাজটি করে alias analysis বা points-to analysis.

# IR of: *a = 1; *b = 2; return *a;
code = [("store", "a", 1), ("store", "b", 2), ("load", "a"), ("ret",)]

def may_alias(p, q, restrict):      # no promise: assume the worst
    return p == q or not restrict

def forward(code, restrict):         # store-to-load forwarding
    known, out = {}, []              # pointer -> value it surely holds
    for ins in code:
        if ins[0] == "store":
            _, p, v = ins
            for q in list(known):    # a store may clobber aliases
                if may_alias(p, q, restrict):
                    del known[q]
            known[p] = v
            out.append(ins)
        elif ins[0] == "load" and ins[1] in known:
            out.append(("const", known[ins[1]]))   # load removed
        else:
            out.append(ins)
    return out

def run(code, a, b):                 # a, b: addresses in a tiny memory
    mem, env, acc = {}, {"a": a, "b": b}, None
    for ins in code:
        if ins[0] == "store": mem[env[ins[1]]] = ins[2]
        elif ins[0] == "load": acc = mem[env[ins[1]]]
        elif ins[0] == "const": acc = ins[1]
        elif ins[0] == "ret": return acc

for restrict in (False, True):
    opt = forward(code, restrict)
    print("restrict" if restrict else "no promise", "->", opt[2])
    print("   a!=b:", run(opt, 100, 104), "| a==b:", run(opt, 100, 100),
          "| unoptimized a==b:", run(code, 100, 100))

আসল আউটপুট (ব্রাউজারের Python):

no promise -> ('load', 'a')
   a!=b: 1 | a==b: 2 | unoptimized a==b: 2
restrict -> ('const', 1)
   a!=b: 1 | a==b: 1 | unoptimized a==b: 2

প্রতিশ্রুতি ছাড়া *b = 2-এর store “a-র ঘরের মান 1” তথ্যটি মুছে দেয় (may alias), তাই load থেকে যায়, আর optimized কোড সব ক্ষেত্রে মূল কোডের সমান উত্তর দেয়: Clang-এর set_two-এর মতো। Restrict দিলে তথ্যটি টিকে থাকে, load-টি const 1 হয়ে যায়: Clang-এর set_two_r. a ≠ b হলে সব ঠিক, কিন্তু a == b হলে optimized কোড 1 দেয় আর মূল কোড 2: ঠিক উপরের -O2 run-এর ঘটনা। একটি optimization সঠিক কেবল তখনই, যখন সব বৈধ চলার পথে আচরণ বদলায় না; restrict ভাঙা পথকে C “বৈধ” বলে না, তাই compiler দায়মুক্ত। অনুশীলন ৪-এ এর একটি ছোট প্রমাণ লিখবেন।

অন্য ভাষাগুলো একই সমস্যার অন্য উত্তর দেয়। Fortran বহু আগে থেকেই ধরে নেয় যে একটি subroutine-এর যে argument-এ লেখা হয়, সেটি অন্য argument-এর alias নয়; সংখ্যা-হিসাবের কোডে Fortran-এর গতির এটি একটি প্রচলিত ব্যাখ্যা। C-তে আরেকটি নিয়ম আছে, strict aliasing (C17 §6.5 অনুচ্ছেদ ৭): একটি int-কে float * দিয়ে পড়া undefined, তাই compiler ধরে নিতে পারে ভিন্ন type-এর pointer সাধারণত একে অপরের alias নয় (type-based alias analysis). আর Rust-এ &mut T নিয়ম অনুযায়ী একমাত্র পথ, তাই restrict-এর প্রতিশ্রুতি সেখানে ভাষাই দেয়, compiler তা যাচাইও করে; rustc এই তথ্য LLVM-কে noalias হিসেবে দেয় বলে জানা যায়।

৫ · Dangling pointer আর use-after-free — বাড়ি বদলেছে, চিরকুট রয়ে গেছে

পর্ব ১৬-এ (Lifetime আর storage) একটি dangling pointer তৈরির প্রথম পথ দেখেছেন: function থেকে local variable-এর ঠিকানা ফেরত দেওয়া, যেখানে Clang -Wreturn-stack-address warning দেয়। সেটি আবার দেখাব না। এখানে দ্বিতীয় পথ, যা বাস্তবে আরও বেশি ক্ষতি করে: heap-এর ঘর free করার পরে তার কোনো alias দিয়ে আবার পড়া বা লেখা, অর্থাৎ use-after-free.

Store-এর ভাষায় ব্যাপারটি সরল। free(ℓ) ঘরটিকে store থেকে সরায়: σ′ = σ \ {ℓ}. এরপর যে pointer-এর মান ℓ, তার ওপর (Deref) নিয়মের কোনো অর্থ নেই, কারণ σ′(ℓ) সংজ্ঞায়িত নয়; C একে undefined behavior বলে। আসল বিপদ পরের ধাপে: allocator পরের malloc-এ একই ℓ আবার দিতে পারে, তখন σ″(ℓ) আবার সংজ্ঞায়িত, কিন্তু অন্য object-এর মান। পুরোনো pointer এখন নীরবে অন্য কারও ডেটা পড়ে আর লেখে। নিচের ছোট heap simulator ঠিক এটি দেখায়; ঠিকানাগুলো এখানে সাধারণ সংখ্যা, আসল মেমরি নয়।

mem, free_list, next_addr = {}, [], 0x10   # a toy heap: address -> value
def malloc(value):
    global next_addr
    if free_list:
        addr = free_list.pop()                 # reuse the last freed box
    else:
        addr, next_addr = next_addr, next_addr + 8
    mem[addr] = value
    return addr
def free(addr):
    free_list.append(addr)                     # value stays, box is "returned"
def show(note):
    print(f"{note:<24}", {hex(a): v for a, v in sorted(mem.items())})

p = malloc(1040)                # order A of one customer
q = p                           # alias: same address, two names
mem[q] = 936                    # write through q ...
print("p == q:", p == q, "| *p =", mem[p])   # ... and p sees it
show("after *q = 936")
free(p); p = None               # p is cleaned up, q is forgotten
r = malloc(60)                  # order B of another customer
print("q =", hex(q), "| r =", hex(r), "| same box:", q == r)
print("*q reads", mem[q], "(order B's data, not 936)")
mem[q] = 0                      # use-after-free write
show("after *q = 0")
print("order B is now", mem[r])

আসল আউটপুট (ব্রাউজারের Python):

p == q: True | *p = 936
after *q = 936           {'0x10': 936}
q = 0x10 | r = 0x10 | same box: True
*q reads 60 (order B's data, not 936)
after *q = 0             {'0x10': 0}
order B is now 0

কোনো error ওঠেনি, আর সেটাই সমস্যা। p = None লিখে প্রোগ্রামার ভেবেছেন কাজ শেষ, কিন্তু alias q তখনো পুরোনো ঠিকানা ধরে আছে। Allocator সেই ঘর দ্বিতীয় গ্রাহকের অর্ডারকে দিয়েছে, তাই q দিয়ে পড়লে অন্য গ্রাহকের ডেটা, আর লিখলে অন্য গ্রাহকের অর্ডার নষ্ট। বাস্তব allocator-এর নিয়ম আলাদা (কোন ঘর কখন আবার দেবে তা বাস্তবায়নের ব্যাপার), কিন্তু ঘর পুনর্ব্যবহারের এই ধরনটি বাস্তবেও সাধারণ।

1p = malloc(1040)2q = p3mem[q] = 9364free(p); p = None5r = malloc(60)6mem[q]          # read7mem[q] = 0      # write8mem[r]
এই ধাপের পরে
p
q
r
ঘর 0x10
free list
  1. Allocation. গ্রাহক A-র অর্ডারের জন্য ঘর 0x10, মান 1040.
  2. Alias. q = p: ঠিকানা কপি হলো, ঘর নয়। এখন দুটি চিরকুট, একটি বাড়ি।
  3. এক নামে লেখা। q দিয়ে 936 লেখা হলো, p দিয়ে পড়লেও 936.
  4. Free. ঘরটি allocator-কে ফেরত (free list-এ 0x10). p-কে None করা হলো, কিন্তু q-এর কথা ভুলে যাওয়া হয়েছে: q এখন dangling. মান 936 ঘরে পড়ে আছে, কিন্তু তার মালিক আর কেউ নয়।
  5. পুনর্ব্যবহার। গ্রাহক B-র অর্ডারের জন্য allocator একই 0x10 দিল, মান 60. এখন r আর পুরোনো q একই ঘর দেখায়।
  6. Use-after-free পড়া। q দিয়ে পড়লে 60: A-র হিসাবে B-র ডেটা ঢুকে গেল। কোনো error নেই।
  7. Use-after-free লেখা। q দিয়ে 0 লেখা হলো; এটি আসলে B-র অর্ডার বদলে দিল।
  8. ফল। B-র মালিক r দিয়ে পড়ে পান 0. ভুলটি ঘটেছে এক জায়গায়, ধরা পড়ল সম্পূর্ণ অন্য জায়গায়: use-after-free খুঁজে পাওয়া এত কঠিন এই কারণেই। নিরাপত্তার দিক থেকে এটি গুরুতর, কারণ ঘরটি তখন অন্য ডেটার হাতে; বিস্তারিত Cybersecurity কোর্সের পর্ব ৪৭-এ।

সত্যিকারের C — compiler কতটা ধরে

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

int main(void) {
    int *order = malloc(sizeof *order);
    if (order == NULL) return 1;
    *order = 1040;
    int *alias = order;       /* second pointer to the same box */
    free(order);              /* box returned to the allocator */
    order = NULL;             /* this pointer is now safe ... */
    printf("%d\n", *alias);   /* ... but the alias still dangles */
    return 0;
}
~/haat $ zig cc -std=c17 -Wall -Wextra -c uaf.c -o uaf.o
~/haat $ zig cc -std=c17 --analyze -c uaf.c -o uaf.plist
uaf.c:11:20: warning: Use of memory after it is released [unix.Malloc]
   11 |     printf("%d\n", *alias);   /* ... but the alias still dangles */
      |                    ^~~~~~
1 warning generated.

সত্যিকারের run, Clang 22.1.8 (zig-এর একটি অপ্রাসঙ্গিক “argument unused” লাইন বাদ)। সাধারণ compile: -Wall -Wextra-এ একটিও warning নেই; compiler-এর সাধারণ পরীক্ষা প্রতিটি function-কে আলাদাভাবে, দ্রুত দেখে, pointer-এর ইতিহাস মনে রাখে না। Clang Static Analyzer (--analyze): একটি static analyzer, যা program না চালিয়ে প্রতিটি সম্ভাব্য পথ ধরে হাঁটে আর মনে রাখে কোন ঘর free হয়েছে; সে ঠিক লাইন ১১ কলাম ২০ দেখিয়েছে, unix.Malloc নামের checker থেকে। তবে analyzer-ও সব ক্ষেত্র ধরে না: pointer যখন অনেক function আর ফাইল ঘুরে আসে, তখন সে হাল ছেড়ে দেয় বা ভুল সতর্কতা দেয়; পর্ব ১৬-এর প্রশ্ন ০২-এ দেখেছেন কেন সাধারণভাবে নির্ভুল উত্তর অসম্ভব (Rice-এর theorem).

চলার সময়ের পাহারাদার হলো AddressSanitizer (ASan, -fsanitize=address): compiler প্রতিটি মেমরি পড়া-লেখার আগে একটি পরীক্ষা বসায়, free করা ঘরগুলোকে কিছুক্ষণ “quarantine”-এ রাখে যাতে সঙ্গে সঙ্গে আবার না দেওয়া হয়, আর ভুল ঘটলেই কোথায় ঘরটি তৈরি আর free হয়েছিল তা ছাপে। এই Zig build-এ Windows-এর জন্য ASan-এর runtime library নেই (link-এর সময় undefined symbol: __asan_report_store4), তাই এখানে চালানো যায়নি; Linux-এ GCC বা Clang দিয়ে এটি সাধারণভাবে পাওয়া যায়। C++-এর দিক থেকে ASan হাতে-কলমে আছে C++ কোর্সের পর্ব ১৮-এ।

স্তরউপায়সীমা
প্রোগ্রামারের অভ্যাসfree-এর পরে pointer NULL করাশুধু ওই একটি নাম রক্ষা পায়, alias নয় (উপরের alias)
Static analysisClang --analyze, অন্যান্য analyzerসব পথ ধরা অসম্ভব; ভুল সতর্কতাও আসে
Runtime পরীক্ষাASan, debug allocatorশুধু যে পথটি চলল সেটিই ধরে; গতি কমে, তাই সাধারণত testing-এ
ভাষার নকশাGC (Java, Python), ownership (Rust), smart pointer (C++)GC-তে runtime খরচ; Rust-এ শেখার কষ্ট; C++-এ নিয়ম স্বেচ্ছায় মানতে হয়

৬ · Null — “কিছুই না” দেখানো pointer আর তার বিকল্প

প্রতিটি pointer type-এ একটি বিশেষ মান থাকে যা কোনো ঘর দেখায় না: C-র NULL, C++-এর nullptr, Java আর JavaScript-এর null, Python-এর None. Tony Hoare ১৯৬৫ সালে ALGOL W-এ null reference যোগ করেছিলেন, আর পরে একে নিজের “billion-dollar mistake” বলেছেন; সেই গল্প আর তার ভাষা-নকশার দিক পর্ব ০৬-এ (ভাষা নকশার লক্ষ্য আর আপস)। এখানে প্রশ্ন বাস্তবায়নের: null দিয়ে ভেতরে ঢুকলে কী হয়, আর কোন নকশায় তা compile-এর সময়েই ধরা যায়।

ভাষাx.total বা *p, যখন x/p nullধরন
C17Undefined behavior; বেশিরভাগ OS-এ ঠিকানা 0-এর পাতা নিষিদ্ধ, তাই সাধারণত crash (segmentation fault), কিন্তু নিশ্চয়তা নেইচলার সময়, অনির্ধারিত
Java 21NullPointerException; Java 15 থেকে ডিফল্টে বার্তায় বলা থাকে কোন অংশটি null ছিলচলার সময়, নির্ধারিত exception
Python 3.14AttributeError: 'NoneType' object has no attribute 'total'চলার সময়, নির্ধারিত exception
JavaScriptTypeError (অংশ ৩-এর run)চলার সময়, নির্ধারিত exception
Kotlin, Swift, TypeScript (strictNullChecks), C# 8+ (nullable চালু থাকলে)যাচাই না করে লিখলে compile error বা warningচলার আগে
Rust, Haskell, OCamlসাধারণ reference-এ null নেই; “না-থাকা” লেখা হয় Option/Maybe দিয়েচলার আগে

শেষ দুই সারির মূল চিন্তা একই: “হয়তো নেই” কথাটি type-এ লেখা। সাধারণ String কখনো null নয়; null হতে পারে শুধু String? (Kotlin, Swift-এর Optional), যাকে বলে nullable type. গাণিতিকভাবে T? = T + {null}, অর্থাৎ দুই রকম মানের একটি যোগফল, আর Option type সেই যোগফলের নাম দেওয়া রূপ: Rust-এর Option<T> = Some(T) অথবা None. এই “যোগফল type” (sum type) আর pattern matching-এর পূর্ণ আলোচনা পরের পর্বে, পর্ব ২৪-এ (Algebraic data type আর pattern matching). C++17-এর std::optional একই ধারণা, তবে ভেতরে ঢোকার আগে যাচাই করা বাধ্যতামূলক নয়।

Type checker কীভাবে জানে কোথায় যাচাই হয়ে গেছে? Kotlin-এর “smart cast” আর TypeScript-এর “narrowing” একই কৌশল: if (x != null)-এর ভেতরে x-এর type T? থেকে সংকুচিত হয়ে T হয়ে যায়। এটি flow-sensitive typing: একই variable-এর type কোডের এক জায়গায় এক, অন্য জায়গায় আরেক। নিচে Python-এর নিজের ast module দিয়ে একটি ছোট checker; সে find_order-এর ফলকে “হয়তো None” ধরে, আর শাখার শর্ত দেখে সেই তথ্য সংকুচিত করে।

import ast
src = """def receipt(no):
    o = find_order(no)
    print(o.total)
    if o is not None:
        print(o.total)
    q = find_order(no)
    if q is None:
        return 0
    return q.total + o.total
"""
def null_test(t):          # ("x", True) for `x is None`, False for `is not`
    if isinstance(t, ast.Compare) and isinstance(t.left, ast.Name) \
            and getattr(t.comparators[0], "value", 0) is None:
        return t.left.id, isinstance(t.ops[0], ast.Is)
def uses(node, maybe):     # report o.attr where o may be None
    for n in ast.walk(node):
        if isinstance(n, ast.Attribute) and getattr(n.value, "id", "") in maybe:
            print(f"line {n.lineno}: '{n.value.id}' may be None here")
def check(stmts, maybe):
    for s in stmts:
        if isinstance(s, ast.Assign):
            uses(s.value, maybe)
            name, v = s.targets[0].id, s.value
            optional = isinstance(v, ast.Call) and v.func.id == "find_order"
            maybe = maybe | {name} if optional else maybe - {name}
        elif isinstance(s, ast.If) and (nt := null_test(s.test)):
            x, is_none = nt
            check(s.body, maybe | {x} if is_none else maybe - {x})
            check(s.orelse, maybe - {x} if is_none else maybe | {x})
            if is_none and isinstance(s.body[-1], ast.Return):
                maybe = maybe - {x}          # early return narrows
        else:
            uses(s, maybe)
check(ast.parse(src).body[0].body, set())

আসল আউটপুট (ব্রাউজারের Python):

line 3: 'o' may be None here
line 9: 'o' may be None here

পরীক্ষিত function-এ (def receipt লাইন ১) .total পড়া হয়েছে চারবার। লাইন ৩ ধরা পড়েছে, কারণ সেখানে কোনো যাচাই নেই। লাইন ৫ নিরাপদ, কারণ is not None শাখার ভেতরে o “সংকুচিত”. লাইন ৯-এ q.total নিরাপদ, কারণ if q is None: return 0 শেষ হলে বাকি পথে q থাকতেই হবে: “early return” দিয়ে সংকোচন, যা Kotlin আর TypeScript-ও বোঝে। কিন্তু একই লাইনের o.total আবার ধরা পড়েছে: লাইন ৪-এর যাচাই শুধু তার নিজের শাখার ভেতরে খাটে, শাখা থেকে বেরোলে o আবার “হয়তো None”. বাস্তব checker (যেমন mypy, যা Python-এর Optional type hint দেখে) এর চেয়ে অনেক বেশি ক্ষেত্র সামলায়: loop, assignment-এর পরে তথ্য মুছে ফেলা, function-এর ভেতর দিয়ে তথ্য পাঠানো। কিন্তু মূল কৌশল এটাই: প্রতিটি বিন্দুতে “কে হয়তো None” তথ্যের একটি set, আর শাখা অনুযায়ী তার বদল। পর্ব ৬৪-এর dataflow analysis এই চিন্তাকেই সাধারণ নিয়মে বাঁধে।

Option-এর একটি সুন্দর বাস্তবায়ন-ফল আছে। Rust-এর documentation অনুযায়ী Option<&T>-এর আকার একটি সাধারণ pointer-এর সমান: যেহেতু &T কখনো শূন্য ঠিকানা হতে পারে না, compiler শূন্যকেই None-এর চিহ্ন হিসেবে ব্যবহার করে (“null pointer optimization”). অর্থাৎ মেশিনের স্তরে আবার সেই পুরোনো null, কিন্তু type checker নিশ্চিত করেছে যে যাচাই ছাড়া কেউ তার ভেতরে ঢুকবে না। নিরাপত্তা এসেছে নকশা থেকে, বাড়তি খরচ থেকে নয়।

৭ · Smart pointer — মালিকানা type-এ লেখা

অংশ ৫-এর মূল সমস্যা ছিল দায়ের অস্পষ্টতা: দুটি pointer, কিন্তু কোনটি ঘরের মালিক, কে free করবে, তা কোডের কোথাও লেখা নেই। C++ এর উত্তর দেয় smart pointer দিয়ে: একটি ছোট class, যা pointer-এর মতো ব্যবহার করা যায়, কিন্তু নিজের destructor-এ ঘর ফেরত দেয় (পর্ব ১৬-এর RAII). C++11-এ তিনটি মান্য রূপ এসেছে:

  • std::unique_ptr: ঠিক একজন মালিক। কপি করা যায় না, শুধু move করা যায়; move-এর পরে পুরোনো নামটি খালি। ভেতরে সাধারণত শুধু একটি pointer, তাই বাড়তি খরচ প্রায় নেই।
  • std::shared_ptr: ভাগাভাগি মালিকানা। একটি আলাদা “control block”-এ গুনে রাখে কয়জন মালিক (reference counting); শেষ মালিক চলে গেলে object মোছে।
  • std::weak_ptr: দেখে কিন্তু মালিক নয়; গণনা বাড়ায় না। ব্যবহারের আগে জিজ্ঞেস করতে হয় object এখনো আছে কি না।
#include <cstdio>
#include <memory>
#include <utility>

struct Order {
    int total;
    explicit Order(int t) : total(t) { std::printf("  make order %d\n", total); }
    ~Order() { std::printf("  free order %d\n", total); }
};

int main() {
    std::unique_ptr<Order> a = std::make_unique<Order>(936);
    std::unique_ptr<Order> b = std::move(a);         // ownership moves
    std::printf("after move: a %s, b->total = %d\n", a ? "owns" : "is empty", b->total);

    std::shared_ptr<Order> s1 = std::make_shared<Order>(996);
    std::weak_ptr<Order> w = s1;                      // watches, does not own
    std::printf("use_count = %ld\n", s1.use_count());
    {
        std::shared_ptr<Order> s2 = s1;               // second owner
        std::printf("use_count = %ld\n", s1.use_count());
    }                                                 // s2 dies here
    std::printf("use_count = %ld\n", s1.use_count());
    s1.reset();                                       // last owner gone
    std::printf("weak expired: %s\n", w.expired() ? "yes" : "no");
    std::printf("end of main\n");
}                                                     // b frees 936 here
~/haat $ zig c++ -std=c++20 -Wall -Wextra smart.cpp -o smart.exe && ./smart.exe
  make order 936
after move: a is empty, b->total = 936
  make order 996
use_count = 1
use_count = 2
use_count = 1
  free order 996
weak expired: yes
end of main
  free order 936
1auto a = make_unique<Order>(936);2auto b = std::move(a);3auto s1 = make_shared<Order>(996);4weak_ptr<Order> w = s1;5{ auto s2 = s1;6}7s1.reset();8}   // end of main
এই ধাপের পরে
Order 936-এর মালিক
Order 996-এর মালিক
use_count
w (weak)
  1. একক মালিক। Heap-এ Order 936, মালিক a.
  2. Move. মালিকানা b-তে গেল; a এখন খালি (null). কপি করতে চাইলে (auto c = b;) compile error, কারণ unique_ptr-এর copy constructor মুছে দেওয়া। দুই মালিক অসম্ভব, তাই double free-ও অসম্ভব।
  3. ভাগাভাগি মালিকানা। make_shared: Order 996, use_count = 1. w দেখছে, কিন্তু গণনায় যোগ হয়নি।
  4. দ্বিতীয় মালিক। Block-এর ভেতরে s2 = s1: object কপি হয়নি, গণনা 2.
  5. Block শেষ। s2-এর destructor গণনা কমায়: 1. Object বেঁচে থাকে, কারণ s1 এখনো মালিক।
  6. শেষ মালিক যায়। s1.reset(): গণনা 0, তাই সঙ্গে সঙ্গে destructor চলে, “free order 996”. w এখন expired: ঘরটি নেই, আর w নিজে থেকেই তা জানে; এটিই dangling-এর বিপরীত।
  7. main শেষ। b-এর scope শেষ, তাই Order 936 মোছে, সবশেষে। একটিও delete লেখা হয়নি, তবু প্রতিটি ঘর ঠিক একবার ফেরত গেছে (সত্যিকারের run-এর শেষ লাইন)।

Smart pointer সব সমস্যা মেটায় না। দুটি object যদি shared_ptr দিয়ে একে অপরকে ধরে রাখে (ধরুন একটি Order তার Customer-কে, আর Customer তার Order-গুলোকে), গণনা কখনো শূন্য হয় না: একটি reference cycle, ফলে leak. সমাধান একদিকের link-কে weak_ptr করা। এই একই সমস্যা CPython-এর reference counting-এও আছে, যার জন্য সেখানে আলাদা cycle collector চলে (পর্ব ১৬-এর run). আর C++-এ smart pointer ব্যবহার স্বেচ্ছায়: কেউ .get() দিয়ে ভেতরের raw pointer বের করে রেখে দিলে dangling আবার সম্ভব। অনুশীলন ২-এ এমন একটি ফাঁদ দেখবেন। হাতে-কলমে পুরো আলোচনা C++ কোর্সের পর্ব ১৭-এ। Rust-এ একই তিনটি ধারণার নাম Box<T>, Rc<T>/Arc<T> আর Weak<T>, কিন্তু সেখানে নিয়ম ভাঙা compiler-ই আটকায় (উদাহরণ, এখানে চালানো হয়নি; পর্ব ৭৬)।

৮ · Haat-এ pointer নেই, তবু ভাগাভাগি আছে — আর compiler-এর চোখ

Haat v1-এর নকশায় pointer নেই, আর থাকার দরকারও কম: Int, Bool আর Str অপরিবর্তনীয় মান, কপি করলে কিছু হারায় না। কিন্তু Haat-এ একটি জায়গায় দুটি পথ একই ঘরে পৌঁছায়: closure. Haat-এর spec অনুযায়ী closure বাইরের variable ধরে by reference, তাই একই var ধরা দুটি function একই ঘর ভাগ করে, যা একটি নিয়ন্ত্রিত aliasing. সত্যিকারের run:

// বাজারঘর: একই stock, দুই function
fn demo() {
    var stock = 10;
    fn sell(n: Int) -> Int { stock = stock - n; return stock; }
    fn restock(n: Int) -> Int { stock = stock + n; return stock; }
    print(sell(3));
    print(restock(5));
    var copy = stock;
    copy = 0;
    print(stock);
    print(copy);
}
demo();
~/haat $ python haat.py run share.haat
7
12
12
0
~/haat $ python haat.py dis share.haat      # part of demo, trimmed
   0  CONST          0     ; 10
   1  MAKE_CELL      0     ; stock
   2  MAKE_CLOSURE   1     ; <fn sell> captures stock
   3  STORE_LOCAL    1     ; sell
   4  MAKE_CLOSURE   2     ; <fn restock> captures stock
   ...
  14  LOAD_CELL      0     ; stock
  15  STORE_LOCAL    3     ; copy

সত্যিকারের run (Haat reference, CPython 3.14.4; vm দিয়েও হুবহু একই চারটি লাইন)। sell 10 থেকে 7 করল, আর restock সেই 7 থেকেই 12 করল: দুটি closure একই ঘর দেখে। Bytecode-এ কারণটি স্পষ্ট: stock একটি cell-এ (MAKE_CELL 0), আর দুটি MAKE_CLOSURE-ই সেই cell-এর reference নিজের ভেতরে রাখে। অন্যদিকে var copy = stock; হলো LOAD_CELL তারপর STORE_LOCAL: মানটি কপি হয়ে সাধারণ ঘরে গেল, তাই copy = 0 stock-কে ছোঁয় না (শেষ দুই লাইন 12 আর 0). অর্থাৎ Haat-এর ভেতরের বাস্তবায়নে cell হলো একটি লুকানো pointer; ভাষা শুধু ঠিক যতটুকু ভাগাভাগি দরকার ততটুকু দেয়, ঠিকানা-গণিত বা free ছাড়া। Closure-এর পুরো গল্প পর্ব ১৭-এ (Closure).

Haat-এ free-ও নেই, তাই dangling সম্ভব নয়: একটি cell বেঁচে থাকে যতক্ষণ কোনো closure তাকে দেখায়। Reference VM-এ কাজটি করে CPython-এর নিজের মেমরি ব্যবস্থাপনা; পর্ব ৭৫-এ আপনি Haat-এর জন্য নিজে একটি mark-sweep garbage collector বানাবেন, তখন এই cell আর closure-গুলোই হবে heap-এর object, আর তাদের ভেতরের reference-গুলো ধরে collector হাঁটবে।

Compiler pointer নিয়ে কী কী প্রশ্ন করে

প্রশ্নবিশ্লেষণের নামকাজে লাগে
এই pointer কোন কোন object দেখাতে পারে?Points-to analysisStore-to-load forwarding, dead store মোছা, পর্ব ৬৫
এই দুটি ঠিকানা কি কখনো এক?Alias analysis (type-based, restrict)Load সরানো, vectorization, পর্ব ৬৬
এই object কি function-এর বাইরে যায়?Escape analysisHeap-এর বদলে stack, পর্ব ১৬ আর ৬১
এই reference কি এখনো জীবিত ঘর দেখায়?Lifetime/borrow checkingRust-এর compile-time নিরাপত্তা, পর্ব ৭৬
এখানে কি null থাকতে পারে?Nullability (flow-sensitive typing)Kotlin/TypeScript-এর error, অংশ ৬

আরও গভীরে: নিখুঁত alias analysis সাধারণভাবে অসম্ভব: William Landi ১৯৯২ সালে দেখান যে pointer-ওয়ালা ভাষায় “এই দুটি expression কি কখনো একই ঘর?” প্রশ্নটি undecidable, তাই বাস্তব compiler নিরাপদ দিকের আনুমানিক উত্তর নেয়। সবচেয়ে প্রচলিত দুটি পদ্ধতির নাম তাদের উদ্ভাবকদের নামে: Lars Ole Andersen-এর (১৯৯৪) inclusion-based বিশ্লেষণ বেশি নির্ভুল কিন্তু ধীর, আর Bjarne Steensgaard-এর (১৯৯৬) unification-based বিশ্লেষণ প্রায় রৈখিক সময়ে চলে কিন্তু মোটা দাগে। হার্ডওয়্যারও এগিয়ে আসছে: Cambridge-এর CHERI গবেষণায় pointer নিজেই সীমা আর অনুমতিসহ একটি “capability”, আর ARM-এর Memory Tagging Extension (MTE) প্রতিটি ঘর আর pointer-এ একটি ছোট tag বসিয়ে মেলে না এমন ব্যবহার ধরে।

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

  • int a[10], base 2000, int ৪ byte: a + 3 কোথায়? 2000 + 3 × 4 = 2012; pointer arithmetic-এর একক ঘর, byte নয়।
  • Pointer আর reference-এর পার্থক্য (C++)? Reference null হয় না, অন্য object-এ সরানো যায় না, arithmetic নেই; pointer তিনটিই পারে।
  • Java কি “pass by reference”? না; reference-এর মানটি কপি হয় (call by sharing). Object বদলানো যায়, ডাকা-পক্ষের variable সরানো যায় না।
  • Dangling pointer কী, দুটি কারণ? যে pointer-এর ঘরের lifetime শেষ: local-এর ঠিকানা ফেরত দেওয়া, আর free-এর পরে কোনো alias ব্যবহার।
  • restrict কী দেয়? প্রোগ্রামারের প্রতিশ্রুতি যে এই pointer-এর ঘরে অন্য পথে পৌঁছানো হবে না; compiler load সরাতে পারে, ভাঙলে undefined behavior.

৯ · AI-এর যুগে pointer আর reference

Pointer-এর প্রশ্নে AI assistant প্রায়ই আত্মবিশ্বাসী আর ভুল একসঙ্গে। এই বিষয়ে বারবার দেখা ভুল আর ধরার উপায়:

AI-এর ভুলকীভাবে ধরবেন
“Java/Python pass by reference” বলা, বা C++ reference-এর নিয়ম Java-তে চাপানোParameter-কে নতুন object-এ সরিয়ে ডাকা-পক্ষ বদলায় কি না চালিয়ে দেখা
Use-after-free বা restrict ভাঙার ফল নিশ্চিত বলা (“পুরোনো মানই আসবে”)-O0 আর -O2 দুই build চালানো; C standard-এ “undefined” লেখা আছে কি না দেখা
Pointer arithmetic-এ byte আর ঘর গুলিয়ে ফেলা(char *)q - (char *)p আর q - p দুটিই ছেপে মেলানো
“Optimization” করতে গিয়ে load সরানো বা restrict বসানো, যেখানে alias সম্ভবএকই ঘর দুই argument-এ পাঠিয়ে আগের আর পরের কোডের ফল তুলনা (differential test)
বানানো compiler flag বা analyzer checker-এর নামনিজের compiler-এ চালিয়ে দেখা; checker-এর নাম আসল output থেকে নেওয়া
GC বা shared_ptr নিয়ে ভুল নিশ্চয়তা (“cycle থাকলেও মুছে যাবে”)Destructor বা finalizer-এ ছাপ রেখে চালানো; use_count ছাপা

AI-কে ভালোভাবে কাজে লাগানোর উপায়: ভাষা আর version বলে দেওয়া, প্রতিটি pointer-এর মালিক কে তা আলাদা করে চাওয়া, আর কোন দাবি নিজে চালিয়ে যাচাই করতে হবে তা জিজ্ঞেস করা।

আমি প্রোগ্রামিং ভাষার pointer আর reference শিখছি। নিচের কোডটি [C17 / C++20 / Java 21 / Python 3.14] ভাষার। তুমি: ১. প্রতিটি pointer বা reference কোন object দেখায়, আর কোথায় দুটি নাম একই object দেখায় (aliasing), লাইন ধরে লেখো। ২. প্রতিটি heap object-এর মালিক কে, আর কে কখন সেটি ফেরত দেবে, বলো। ৩. Dangling pointer, use-after-free, double free, null dereference বা সীমার বাইরের pointer arithmetic আছে কি না দেখো; থাকলে লাইন নম্বর দাও আর নিরাপদ বিকল্প দেখাও। ৪. কোনো আচরণ undefined হলে স্পষ্ট লেখো; কোনো আউটপুট অনুমান করে লিখবে না। ৫. কোন compiler flag, sanitizer বা analyzer দিয়ে আমি নিজে চালিয়ে মেলাব, বলো। [এখানে কোড]

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

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

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

প্র ০১C কেন pointer arithmetic রেখেছিল, আর Java কেন ঠিকানাই লুকিয়ে ফেলল?

C-র পূর্বপুরুষ BCPL আর B ছিল প্রায় type-হীন: সবকিছু একটি “word”, আর একটি word-কে ঠিকানা হিসেবে ধরে তাতে ১ যোগ করলে পরের word. ১৯৭০-এর দশকের শুরুতে Dennis Ritchie যখন PDP-11-এর জন্য C তৈরি করছিলেন, তখন byte-ভিত্তিক মেমরি আর ভিন্ন আকারের type (char, int) এল, তাই pointer-কে type জানতে হলো: p + 1 মানে “এই type-এর পরের ঘর”. Ritchie-র পরে লেখা ইতিহাস-প্রবন্ধে (“The Development of the C Language”, ১৯৯৩) array আর pointer-এর এই ঘনিষ্ঠ সম্পর্ককে C-র একটি কেন্দ্রীয় নকশা-সিদ্ধান্ত বলা হয়েছে। লক্ষ্য ছিল একটি operating system (Unix) লেখা, যেখানে device register, buffer আর memory allocator-এ সরাসরি ঠিকানা নিয়ে কাজ করতেই হয়, আর তখনকার compiler-এর জন্য pointer-এ হাঁটা index-এর চেয়ে সহজে দ্রুত কোড দিত।

Java (১৯৯৫) একটি ভিন্ন জগতের জন্য তৈরি: network থেকে আসা কোড চালানো, যেখানে একটি ভুল pointer মানে নিরাপত্তা ভাঙা। তাই Java-র reference শুধু object-এর দিকে তীর: যোগ-বিয়োগ নেই, সংখ্যা থেকে reference বানানো নেই, array-তে প্রতিটি index যাচাই হয়। এর একটি কম আলোচিত কিন্তু বড় ফল আছে: যেহেতু প্রোগ্রামার কখনো আসল ঠিকানা দেখেন না, garbage collector object-গুলোকে মেমরিতে সরিয়ে এক জায়গায় জড়ো করতে পারে (compacting বা copying collector), আর শুধু reference-গুলো নতুন ঠিকানায় হালনাগাদ করে। C-তে এটি প্রায় অসম্ভব, কারণ যেকোনো int-এ লুকিয়ে একটি ঠিকানা থাকতে পারে, collector নিশ্চিতভাবে জানে না কোনটি pointer.

আজকের ভাষাগুলো মাঝামাঝি পথ নেয়। Go pointer রাখে কিন্তু arithmetic বাদ দেয়, আর তার collector জানে কোনটি pointer. Rust আর C# “unsafe” অংশে raw pointer আর arithmetic দেয়, বাকি কোডে নয়, যাতে বিপজ্জনক অংশ ছোট আর খুঁজে পাওয়া সহজ থাকে।

মূল উপলব্ধি: ঠিকানা দেখানো মানে ক্ষমতা আর দায় দুটোই প্রোগ্রামারকে দেওয়া; ঠিকানা লুকানো মানে runtime-কে স্বাধীনতা দেওয়া (object সরানো, নিরাপত্তা যাচাই)। কোনটি বেছে নেবেন, তা নির্ভর করে ভাষাটি কোন কাজের জন্য।

প্র ০২Null-এর সমস্যার সমাধান হিসেবে ভাষাগুলো কী কী পথ নিয়েছে, আর প্রতিটির আপস কী?

Tony Hoare ১৯৬৫ সালে ALGOL W-এ null reference এনেছিলেন, কারণ বাস্তবায়ন সহজ ছিল; ২০০৯ সালের একটি সম্মেলন-বক্তৃতায় তিনি একে নিজের “billion-dollar mistake” বলেন। সমস্যাটি গভীরে type system-এর: যদি প্রতিটি reference type-এর মধ্যে null গোপনে লুকিয়ে থাকে, তাহলে “এই variable-এ একটি Order আছে” কথাটি type checker কখনো নিশ্চিত করতে পারে না।

প্রথম পথ, ভালো runtime বার্তা: Java-তে null-এর ভেতরে ঢুকলে NullPointerException, আর Java 15 থেকে ডিফল্টে বার্তায় বলা থাকে ঠিক কোন অংশটি null (JEP 358). ভুল ধরা সহজ হয়, কিন্তু ভুল তবু ঘটে চলার সময়, হয়তো গ্রাহকের সামনে।

দ্বিতীয় পথ, nullable type: Kotlin, Swift, TypeScript-এর strictNullChecks (TypeScript 2.0, ২০১৬) আর C# 8-এর nullable reference type. সাধারণ type null নিতে পারে না; String? পারে, আর তার ভেতরে ঢোকার আগে যাচাই বাধ্যতামূলক, flow-sensitive typing দিয়ে। আপস: পুরোনো কোড আর library-র সঙ্গে মেলানো। Kotlin-কে Java library ডাকতে হয়, যার type-এ null-এর কোনো তথ্য নেই, তাই Kotlin “platform type” নামের একটি ছাড় রাখে; C#-এ বৈশিষ্ট্যটি চালু করতে হয়, আর এর ভুল মূলত warning.

তৃতীয় পথ, null-ই নেই, শুধু Option: ML পরিবার, Haskell-এর Maybe, Rust-এর Option. “না-থাকা” একটি সাধারণ sum type-এর একটি রূপ, আর pattern matching প্রতিটি রূপ সামলাতে বাধ্য করে। আপস: লেখা একটু লম্বা হয়, যদিও map, ? operator-এর মতো সুবিধা তা কমায়; আর অংশ ৬-এ দেখেছেন, Rust-এ এর মেশিন-খরচ প্রায়ই শূন্য।

Haat v1 সবচেয়ে সরল পথ নিয়েছে: reference-ই নেই, প্রতিটি variable ঘোষণার সময়েই মান পায়, তাই null নেই। পর্ব ২৪-এ Haat-এর বর্ধিত রূপে enum আর match এলে “না-থাকা” লেখা যাবে Option-এর মতো করে।

মূল উপলব্ধি: null-এর সমস্যা আসলে type-এর সমস্যা: “থাকতেও পারে, না-ও পারে” কথাটি type-এ লেখা থাকলে type checker ভুলটি চলার আগেই ধরতে পারে।

প্র ০৩Aliasing কেন optimizer-এর সবচেয়ে বড় বাধাগুলোর একটি, আর ভাষার নকশা কীভাবে সাহায্য করতে পারে?

Optimizer-এর প্রায় প্রতিটি কৌশল একটি প্রশ্নের ওপর দাঁড়ায়: “এই মানটি কি মাঝখানে বদলেছে?” Variable শুধু নামে পৌঁছানো গেলে উত্তর সহজ: নামটি কোথায় লেখা হয়েছে দেখলেই হয়। কিন্তু pointer থাকলে যেকোনো *p = … লেখা সম্ভাব্যভাবে যেকোনো ঘর বদলাতে পারে। তখন optimizer-কে হয় প্রমাণ করতে হয় যে p অন্য কোনো ঘর দেখায় না, নয়তো সবচেয়ে খারাপটা ধরে নিতে হয়: মানটি register-এ রাখা যাবে না, load সরানো যাবে না, loop-কে vector নির্দেশে বদলানো যাবে না। অংশ ৪-এ এক লাইনের পার্থক্যই দেখেছেন; বড় loop-এ এটি বহুগুণ হয়।

প্রমাণ করা সহজ নয়। William Landi ১৯৯২ সালে দেখান যে সাধারণ pointer-ওয়ালা ভাষায় নির্ভুল alias analysis undecidable, অর্থাৎ কোনো algorithm সব program-এর জন্য সঠিক উত্তর দিতে পারে না। তাই compiler-গুলো আনুমানিক কিন্তু নিরাপদ বিশ্লেষণ চালায়: Andersen বা Steensgaard-এর মতো points-to analysis, আর type দেখে অনুমান (C-র strict aliasing নিয়ম ধরে নেয় যে int আর float-এর pointer সাধারণত একই ঘর দেখায় না)।

ভাষার নকশা এখানে বড় সাহায্য করতে পারে, তথ্যটি প্রোগ্রামার বা type system থেকে নিয়ে। Fortran-এর নিয়ম ছিল যে subroutine-এর যে argument-এ লেখা হয় তা অন্য argument-এর alias নয়; সংখ্যা-হিসাবের library-তে Fortran দীর্ঘদিন যে গতির সুনাম পেয়েছে, তার একটি প্রচলিত ব্যাখ্যা এটি। C99 এই সুবিধা ঐচ্ছিকভাবে আনে restrict দিয়ে, কিন্তু যাচাই ছাড়া; ভুল প্রতিশ্রুতি মানে undefined behavior, যা অংশ ৪-এ সত্যিকারের run-এ দেখেছেন। Rust নিয়মটিকে type system-এর অংশ করে: &mut T থাকলে ওই ঘরে অন্য কোনো পথ নেই, আর borrow checker তা প্রমাণ করে। Functional ভাষায় মান অপরিবর্তনীয় হলে aliasing নিরাপদ, কারণ কেউ বদলাতেই পারে না।

মূল উপলব্ধি: aliasing-এর তথ্য compiler নিজে বের করতে পারে শুধু আংশিকভাবে; যে ভাষা নকশার মধ্যেই “কে কোথায় লিখতে পারে” বলে দেয়, তার optimizer অনেক সাহসী হতে পারে, আর নিরাপদও থাকে।

প্র ০৪Reference counting, tracing GC আর ownership — smart pointer এই তিনের মধ্যে কোথায় বসে?

তিনটিই একই প্রশ্নের উত্তর: “heap-এর একটি ঘর কখন ফেরত দেওয়া নিরাপদ?” Reference counting প্রতিটি object-এর সঙ্গে একটি গণনা রাখে; George Collins ১৯৬০ সালে list-প্রক্রিয়াকরণের জন্য এই পদ্ধতি বর্ণনা করেন বলে প্রায়ই উদ্ধৃত হয়। সুবিধা: object মরে ঠিক শেষ reference যাওয়ার মুহূর্তে, তাই destructor-এর সময় পূর্বানুমেয়, আর বড় বিরতি নেই। অসুবিধা: প্রতিটি কপি আর মোছায় গণনা বদলানোর খরচ (একাধিক thread-এ সেটি atomic হতে হয়, যা আরও দামি), আর cycle কখনো মোছে না।

Tracing GC (McCarthy-র ১৯৬০ সালের LISP প্রবন্ধে বর্ণিত mark-sweep থেকে শুরু) গণনা রাখে না; মাঝে মাঝে root (stack, global) থেকে সব পৌঁছানো যায় এমন object খুঁজে বাকিগুলো মোছে। Cycle কোনো সমস্যা নয়, কপির খরচ নেই, কিন্তু কখন মুছবে তা অনিশ্চিত আর collector চালাতে সময় লাগে। পর্ব ৭৫-এ দুটিই নিজে বানাবেন।

Ownership (C++-এর RAII, Rust) প্রশ্নটি compile-এর সময়েই মেটায়: প্রতিটি ঘরের একজন মালিক, মালিকের scope শেষ হলে ফেরত। কোনো runtime গণনা নেই।

C++-এর smart pointer এই মানচিত্রে দুই জায়গায় বসে। unique_ptr হলো খাঁটি ownership: একজন মালিক, move দিয়ে হস্তান্তর, কোনো গণনা নেই। shared_ptr হলো reference counting, যা লাইব্রেরিতে বাস্তবায়িত, আর weak_ptr তার cycle-সমস্যার হাতে-কলমে সমাধান। Swift-এর ARC একই reference counting-কে compiler-এর হাতে দেয়: compiler নিজেই গণনা বাড়ানো-কমানোর নির্দেশ বসায়। CPython reference counting আর cycle collector দুটিই চালায়। অর্থাৎ বাস্তব ভাষাগুলো প্রায়ই মিশ্রণ: সাধারণ ক্ষেত্রে সস্তা ও পূর্বানুমেয় পথ, কঠিন ক্ষেত্রে বাড়তি ব্যবস্থা।

নকশার দৃষ্টিতে আরেকটি পার্থক্য: GC-ভাষায় “মালিক” ধারণাটি কোডে কোথাও লেখা থাকে না, তাই ভুলে একটি global cache-এ reference রেখে দিলে leak হয়, আর কেউ জানতেও পারে না। Smart pointer আর ownership মালিকানাকে type-এ লিখে দেয়, ফলে কোড পড়েই বোঝা যায় কে দায়ী।

মূল উপলব্ধি: smart pointer নতুন কোনো memory-ব্যবস্থা নয়; এটি ownership আর reference counting-কে library type হিসেবে প্রকাশ করা, যাতে মালিকানা কোডে দৃশ্যমান হয়।

প্র ০৫Use-after-free ঠেকাতে ভাষা, compiler, runtime আর হার্ডওয়্যার কে কী করতে পারে?

Use-after-free-কে আলাদা করে বিপজ্জনক করে তোলে সময়ের ফাঁক: ভুলটি ঘটে এক জায়গায়, ফল দেখা দেয় অনেক পরে, অন্য কোডে, হয়তো অন্য ডেটায় (অংশ ৫-এর stepper). তাই প্রতিরোধও কয়েক স্তরে।

ভাষা: সবচেয়ে মজবুত সমাধান ভাষার নকশায়। GC-ভাষায় free-ই নেই, তাই প্রশ্ন ওঠে না। Rust-এ borrow checker প্রমাণ করে যে কোনো reference তার মালিকের চেয়ে বেশি দিন বাঁচে না। গত কয়েক বছরে বিভিন্ন সরকারি সাইবার-নিরাপত্তা সংস্থা নতুন কোডে memory-safe ভাষা ব্যবহারের সুপারিশ করেছে বলে জানা যায়; এর পেছনের যুক্তি ঠিক এটাই, ভুলকে লেখার সময়েই অসম্ভব করা।

Compiler আর static analysis: Clang Static Analyzer-এর মতো tool program না চালিয়ে পথগুলো ধরে হাঁটে; অংশ ৫-এ সে ঠিক লাইনটি ধরেছে। কিন্তু Rice-এর theorem অনুযায়ী সব ক্ষেত্র নির্ভুলভাবে ধরা অসম্ভব, তাই কিছু ভুল ফসকায় আর কিছু ভুল সতর্কতা আসে।

Runtime: AddressSanitizer (Konstantin Serebryany ও সহকর্মীদের ২০১২ সালের প্রবন্ধে বর্ণিত) প্রতিটি ঘরের অবস্থা একটি “shadow memory”-তে রাখে, আর free করা ঘরকে কিছুক্ষণ quarantine-এ রেখে ব্যবহার ধরে। Fuzzing-এর সঙ্গে মিলিয়ে বহু ভুল এভাবে খুঁজে পাওয়া যায় (Software Testing কোর্সে fuzzing আছে)। দাম গতি আর মেমরি, তাই সাধারণত testing-এ। কিছু hardened allocator আবার একই ঠিকানা তাড়াতাড়ি ফেরত না দিয়ে ক্ষতি কমায়।

হার্ডওয়্যার: ARM-এর Memory Tagging Extension প্রতিটি ছোট মেমরি-খণ্ড আর pointer-এ একটি tag রাখে; free-এর পরে খণ্ডের tag বদলালে পুরোনো pointer-এর tag আর মেলে না, তাই ব্যবহার ধরা পড়ে, অনুশীলন ১-এর “generation” কৌশলের হার্ডওয়্যার-রূপ। CHERI গবেষণা pointer-কে সীমা আর অনুমতিসহ একটি অজাল-যোগ্য capability বানায়।

মূল উপলব্ধি: পরের স্তরগুলো ভুল ধরে, প্রথম স্তর ভুলকে অসম্ভব করে। যত আগের স্তরে সমাধান, তত কম খরচে আর তত নিশ্চিতভাবে নিরাপত্তা।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — use-after-free ধরা pointer: অংশ ৫-এর খেলনা heap-কে এমনভাবে বদলান যাতে প্রতিটি pointer শুধু ঠিকানা নয়, একটি জোড়া (ঠিকানা, generation) হয়। প্রতিটি ঘরের একটি বর্তমান generation থাকবে; free তা ১ বাড়াবে। (ক) load কখন error দেবে? (খ) একই কৌশলে double free কীভাবে ধরবেন? (গ) এই কৌশলের খরচ আর সীমা কী?

    (ক) pointer-এর generation যদি ঘরের বর্তমান generation-এর সমান না হয়, তাহলে ঘরটি এর মধ্যে free হয়েছে (হয়তো আবার অন্য কাউকে দেওয়াও হয়েছে), তাই error. (খ) free-ও একই পরীক্ষা করবে: পুরোনো generation-এর pointer দিয়ে free মানে ঘরটি আগেই একবার free হয়েছে। লেখকের যন্ত্রে চালানো সমাধানের মূল অংশ:

    def malloc(value):
        ...                               # same reuse rule as before
        mem[addr] = value
        return (addr, gen[addr])          # a pointer = address + generation
    def free(ptr):
        addr, g = ptr
        if gen[addr] != g:
            raise RuntimeError(f"double free at {hex(addr)}")
        gen[addr] += 1                    # every old pointer is now stale
        free_list.append(addr)
    def load(ptr):
        addr, g = ptr
        if gen[addr] != g:
            raise RuntimeError(f"use after free at {hex(addr)} (gen {g}, now {gen[addr]})")
        return mem[addr]
    
    p = malloc(1040); q = p; free(p); r = malloc(60)
    # load(r) -> 60;  load(q) and free(q) raise
    
    r = ('0x10', 1) | load(r) = 60
    caught: use after free at 0x10 (gen 0, now 1)
    caught: double free at 0x10

    (গ) খরচ: প্রতিটি pointer বড় হয় (ঠিকানার পাশে একটি সংখ্যা), আর প্রতিটি পড়া-লেখায় একটি তুলনা। সীমা: generation-এর সংখ্যা সীমিত হলে অনেকবার free-এর পরে ঘুরে আগের মানে ফিরতে পারে, তখন একটি পুরোনো pointer আবার “বৈধ” দেখায়; ARM MTE-র ছোট tag-এ এটি সম্ভাবনার ব্যাপার, নিশ্চয়তা নয়। আর এটি ভুল ধরে, ঠেকায় না: error চলার সময় আসে। তবু নীরব ডেটা-নষ্টের (অংশ ৫-এর order B) চেয়ে স্পষ্ট error অনেক ভালো।

  2. ভুল খুঁজুন: বাজারঘরের একটি C++20 program নিচে। -Wall -Wextra-এ compile হয় কোনো warning ছাড়া (সত্যিকারের run, Clang 22.1.8; Clang Static Analyzer-ও কিছু বলেনি)। ভুলটি কোথায়, কেন, আর দুটি সমাধান দিন।
    std::vector<int> totals = {936, 996};
    int &first = totals[0];        // reference into the vector's buffer
    totals.push_back(5000);        // may move the buffer elsewhere
    first = 0;                     // which box does this write?
    std::printf("totals[0] = %d\n", totals[0]);

    first হলো vector-এর ভেতরের buffer-এর প্রথম ঘরের reference. push_back-এর সময় যদি capacity ফুরিয়ে যায়, vector একটি নতুন, বড় buffer নেয়, মানগুলো সেখানে সরায়, আর পুরোনো buffer ফেরত দেয়। তখন first একটি free করা ঘর দেখায়: dangling reference, আর first = 0 একটি use-after-free লেখা, undefined behavior. ভুলটি সূক্ষ্ম, কারণ কোডে কোথাও delete বা free নেই; ঘরটি ফেরত গেছে library-র ভেতরে। কখন buffer সরবে, তা capacity-র ওপর নির্ভর করে, যা বাস্তবায়নভেদে আলাদা, তাই কোডটি কখনো “ঠিক” চলে, কখনো নয়। C++-এর ভাষায় এটি iterator বা reference invalidation; standard প্রতিটি container-এর জন্য বলে দেয় কোন কাজ reference অচল করে।

    সমাধান: (১) reference নয়, index রাখুন: std::size_t first = 0; আর পরে totals[first] = 0;; index buffer সরলেও অর্থ হারায় না। (২) সব push_back শেষ হওয়ার পরে reference নিন, বা আগেই totals.reserve(3) দিয়ে জায়গা রাখুন (দ্বিতীয়টি ভঙ্গুর: পরে কেউ আরেকটি push_back যোগ করলে ভুল ফিরে আসে)। Rust-এ একই কোড compile হয় না, কারণ first একটি ধার চালু থাকা অবস্থায় vector বদলানো borrow checker নিষেধ করে (উদাহরণ, এখানে চালানো হয়নি)।

  3. আউটপুট অনুমান করুন: C17-এ, int ৪ byte ধরে, নিচের কোড কী ছাপবে? আর array যদি ঠিকানা 0x2000-এ শুরু হয়, p আর q-এর ঠিকানা কত?
    int arr[5] = {10, 20, 30, 40, 50};
    int *p = arr + 1;
    int *q = p + 2;
    printf("%d %d %td %d\n", *p, *q, q - p, *(q - 1) + p[3]);

    p = arr + 1 দেখায় arr[1] = 20. q = p + 2 দেখায় arr[3] = 40. q − p = 2 (ঘর). *(q - 1) = arr[2] = 30, আর p[3] = *(p + 3) = arr[4] = 50; যোগফল 80. সত্যিকারের run:

    ~/haat $ zig cc -std=c17 -Wall -Wextra trace.c -o trace.exe && ./trace.exe
    20 40 2 80
    4 12

    দ্বিতীয় লাইনে একই run-এ byte-এর দূরত্ব ছাপা হয়েছে: p arr থেকে ৪ byte, q ১২ byte দূরে। তাই base 0x2000 হলে p = 0x2004 আর q = 0x200C. সবচেয়ে প্রচলিত ভুল: p[3]-কে arr[3] ভাবা; index গোনা শুরু হয় p থেকে, arr থেকে নয়।

  4. প্রমাণ — store-to-load forwarding কখন সঠিক: store মডেলে *a = 1; *b = 2; return *a; ধরুন, যেখানে a-র মান ঘর ℓa আর b-র মান ℓb. প্রমাণ করুন: (ক) ℓa ≠ ℓb হলে ফল 1, তাই return *a-কে return 1 বানানো সঠিক; (খ) ℓa = ℓb হলে ফল 2, তাই এই রূপান্তর সাধারণভাবে সঠিক নয়।
    1. শুরুর store σ0. প্রথম লেখার পরে (সংজ্ঞা ২৩.১) σ1 = σ0[ℓa ↦ 1].
    2. দ্বিতীয় লেখার পরে σ2 = σ1[ℓb ↦ 2].
    3. ফেরত মান σ2(ℓa). Update-এর সংজ্ঞা: σ[ℓ ↦ v](ℓ′) = v যদি ℓ′ = ℓ, নইলে σ(ℓ′).
    4. (ক) ℓa ≠ ℓb: σ2(ℓa) = σ1(ℓa) = 1. তাই সব এমন ক্ষেত্রে মূল কোড আর রূপান্তরিত কোড একই মান দেয়।
    5. (খ) ℓa = ℓb: σ2(ℓa) = σ2(ℓb) = 2 ≠ 1. একটি বৈধ ইনপুটে (C-তে set_two(&x, &x) সম্পূর্ণ বৈধ) আচরণ বদলায়, তাই restrict ছাড়া রূপান্তরটি অবৈধ। ∎

    এই প্রমাণ থেকেই restrict-এর ভূমিকা স্পষ্ট: restrict থাকলে C standard ℓa = ℓb-এর ক্ষেত্রকে undefined behavior বলে, তাই “সব বৈধ চলা” শুধু (ক)-এর ক্ষেত্র, আর রূপান্তর সঠিক। অংশ ৪-এর Python forward ঠিক এই যুক্তি কোডে লেখে: may_alias মিথ্যা হলে ধাপ ৪ প্রয়োগ হয়। একটি optimization-এর সঠিকতা মানে এভাবে দেখানো যে সব বৈধ store-এ মূল আর নতুন কোডের ফল এক; পর্ব ৬৫-এ এই ধরনের যুক্তি আরও আসবে।

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

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

ক্রমC++20-এ auto a = std::make_unique<Order>(936); auto b = std::move(a); auto s1 = std::make_shared<Order>(996); { auto s2 = s1; } s1.reset(); তারপর main শেষ। ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Order 936 তৈরি, মালিক a
  2. মালিকানা b-তে যায়, a খালি
  3. Order 996 তৈরি, use_count 1
  4. Block-এর ভেতরে s2, use_count 2
  5. Block শেষে use_count আবার 1
  6. reset-এর পরে use_count 0, Order 996 মোছে

C17-এ int a[10]; array-র base address 2000, আর int ৪ byte. a + 3 কোন ঠিকানা দেখায়?

  • 2003
  • 2006
  • 2012
  • 2016

C++-এ int& r = total; লেখার পরে কোন কথাটি সঠিক?

  • পরে r = y; লিখলে r এখন y-কে দেখায়
  • r হলো total-এর স্থায়ী দ্বিতীয় নাম; r-এ লেখা total বদলায়
  • r + 1 পরের int-এর ঘর দেখায়
  • r পরে nullptr বসিয়ে খালি করা যায়

JavaScript: function f(o) { o.x = 1; o = { x: 2 }; } const p = { x: 0 }; f(p); console.log(p.x); কী ছাপবে?

  • 1
  • 2
  • 0
  • TypeError, কারণ p const

C99-এর int *restrict a দিয়ে প্রোগ্রামার কী বলেন?

  • Compiler চলার সময় পরীক্ষা করবে যে a অন্য pointer-এর সমান নয়
  • a দিয়ে শুধু পড়া যাবে, লেখা যাবে না
  • a কখনো NULL হবে না
  • a দিয়ে ছোঁয়া ঘরে অন্য কোনো pointer দিয়ে পৌঁছানো হবে না; ভাঙলে undefined behavior

C17-এ int *q = p; free(p); p = NULL; printf("%d", *q); — শেষ লাইন সম্পর্কে কোনটি সঠিক?

  • নিরাপদ, কারণ p NULL করা হয়েছে
  • Use-after-free; undefined behavior, ফলের কোনো নিশ্চয়তা নেই
  • সবসময় segmentation fault দেয়
  • সবসময় 0 ছাপে, কারণ free মান মুছে দেয়

Kotlin-এর String? বা Rust-এর Option<T>-এর মতো nullable বা Option type-এর মূল সুবিধা কী?

  • Program দ্রুত চলে
  • “মান নেই” অবস্থা প্রকাশ করাই আর যায় না
  • মান না-থাকার সম্ভাবনা type-এ লেখা থাকে, তাই যাচাই ছাড়া ব্যবহার compile-এর সময় ধরা পড়ে
  • Garbage collector null object মুছে দেয়

Haat program: fn demo() { var stock = 10; fn sell(n: Int) -> Int { stock = stock - n; return stock; } fn restock(n: Int) -> Int { stock = stock + n; return stock; } print(sell(3)); print(restock(5)); } demo(); কী ছাপবে?

  • 7, তারপর 12
  • 7, তারপর 15
  • Error: closure বাইরের var বদলাতে পারে না
  • 10, তারপর 15

শব্দকোষ

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

মনে রাখুন

  1. Pointer = ঠিকানা-মান: &x = ρ(x), *e পড়া σ(ℓ), লেখা σ[ℓ ↦ v]. Type (T*) বলে না ঘরটি জীবিত কি না।
  2. Pointer arithmetic-এর একক ঘর: p + k = ঠিকানা + k × sizeof(T); বৈধ শুধু array-র ভেতরে আর শেষের ঠিক পরের ঘর পর্যন্ত; p[k] মানে *(p + k).
  3. Reference তিন রকম: C++ reference স্থায়ী দ্বিতীয় নাম; Java/Python/JS reference কপি হওয়া তীর (call by sharing); Rust reference compile-এর সময় যাচাই করা ধার।
  4. Aliasing আর restrict: alias সম্ভব হলে compiler load রাখে; restrict-এ Clang -O2 load মুছে 1 ফেরত দেয়, আর প্রতিশ্রুতি ভাঙলে ফল ভুল (undefined behavior).
  5. Use-after-free, null আর মালিকানা: free-এর পরে alias-ও dangling; null-এর বিকল্প nullable/Option type; unique_ptr একক মালিক, shared_ptr গণনা, weak_ptr cycle ভাঙে। Haat-এ pointer নেই, ভাগাভাগি শুধু closure-এর cell-এ।

পরের পর্বে: এই পর্বে Option-এর দেখা মিলেছে। পর্ব ২৪-এ (Algebraic data type আর pattern matching) পুরো ছবি: product আর sum type, মানের সংখ্যা গোনা, Haat-এর বর্ধিত রূপে enum Payment আর match, আর compiler কীভাবে দেখে যে কোনো ক্ষেত্র বাদ পড়েনি।

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

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