এই পর্বে যা শিখবেন
- Object, class, encapsulation, inheritance আর polymorphism-এর সঠিক সংজ্ঞা, আর ভাষাভেদে “private”-এর আসল অর্থ
- Subtype rule আর dispatch-এর নিয়ম formal-ভাবে লেখা, আর overriding বনাম overloading আলাদা করা
- Compiler কীভাবে vtable আর vptr দিয়ে virtual call বানায়, সত্যিকারের Clang-এর layout আর assembly পড়ে
- JavaScript-এর prototype chain-এ property খোঁজা, আর Python-এর MRO-র জন্য C3 linearization হাতে হিসাব করা
- Liskov substitution, method type-এর variance আর composition বনাম inheritance-এর আপস যুক্তি দিয়ে বিচার করা
১ · মুদি দোকানের খাতা — object মানে অবস্থা আর আচরণ একসঙ্গে
পাড়ার মুদি দোকানের কথা ভাবুন। দোকানদারের কাছে একটি বাকির খাতা আছে। আপনি খাতাটি হাতে নিয়ে নিজে কিছু লিখতে পারেন না। আপনি শুধু বলেন, “আমার নামে আধা কেজি ডাল লিখে রাখুন” বা “আমার মোট বাকি কত?” দোকানদার নিজের নিয়মে খাতা বদলান আর উত্তর দেন। একই কথা দুই দোকানে বললে দুই রকম উত্তর আসতে পারে, কারণ প্রত্যেকের খাতা আলাদা, নিয়মও আলাদা।
দোকানদার আর তাঁর খাতা মিলে একটি object. খাতার লেখা হলো object-এর অবস্থা (state), দোকানদারের নিয়ম হলো আচরণ (method), আর আপনার অনুরোধ হলো একটি বার্তা। খাতা লুকিয়ে রেখে শুধু অনুরোধের পথ খোলা রাখা হলো encapsulation. আর “একই অনুরোধ, দোকানভেদে আলাদা সাড়া” হলো polymorphism, যা এই পর্বের মূল বিষয়।
আগের পর্বে, পর্ব ০৭-এ (Imperative আর procedural programming), program ছিল ডেটা আর সেই ডেটা বদলানো procedure-এর আলাদা দুটি জগৎ। Object-oriented programming এই দুটিকে এক জায়গায় বাঁধে। এটি একটি programming paradigm, অর্থাৎ program সাজানোর একটি ধরন; কোনো একটি ভাষার নাম নয়। এই মডিউলের প্রতিটি পর্বে একটিই বাজারঘর কাজ আলাদা paradigm-এ সমাধান করা হয়: অর্ডারের তালিকা থেকে প্রতিটি লাইনের দাম, মোট ১০০০ টাকা বা বেশি হলে ১০% ছাড়, শুধু একটি জেলার অর্ডার, আর সবশেষে যোগফল।
একটি object হলো তিনটি জিনিসের জোড়: (১) পরিচয় (identity), অর্থাৎ দুটি object-এর অবস্থা হুবহু এক হলেও তারা আলাদা; (২) অবস্থা, কিছু field বা variable, যা সময়ের সঙ্গে বদলাতে পারে; (৩) আচরণ, কিছু method, যা বার্তা পেলে চলে আর অবস্থা পড়ে বা বদলায়। বার্তা পাঠানোকে লেখা হয় o.m(a1, …, an): object o-কে বার্তা m পাঠানো, সঙ্গে argument a1 থেকে an. বার্তা পেয়ে কোন কোড চলবে, তা ঠিক করে গ্রহণকারী object, পাঠানো কোড নয়।
শেষ বাক্যটিই আসল। Procedural কোডে price(o) লিখলে ঠিক একটি function চলে, যার নাম price. Object-oriented কোডে o.price() লিখলে কোন কোড চলবে, তা নির্ভর করে o আসলে কোন ধরনের object তার ওপর। Smalltalk-এর ঐতিহ্যে একে বলে message passing: আপনি অনুরোধ পাঠান, কাজের পদ্ধতি ঠিক করে গ্রহণকারী।
Haat-এ class নেই, তবু object বানানো যায়
Haat-এর spec v1-এ class, record বা ডট (.) নেই; a.total লিখলে reference বাস্তবায়ন 2:8: error: unexpected character '.' দেয়। কিন্তু Haat-এ function first-class মান, আর closure বাইরের variable reference হিসেবে ধরে রাখে। এই দুটি দিয়েই একটি object বানানো যায়: গোপন অবস্থা থাকবে closure-এর ধরা variable-এ, আর বার্তা হবে একটি সংখ্যা।
// বাজারঘর: closure দিয়ে বানানো একটি "object"
fn make_cart(limit: Int) -> (Int, Int) -> Int {
var total = 0; // গোপন অবস্থা (private state)
fn handle(msg: Int, x: Int) -> Int { // বার্তা 1 = যোগ, 2 = দেয় টাকা
if msg == 1 { total = total + x; return total; }
if msg == 2 {
if total >= limit { return total - total / 10; }
return total;
}
return 0 - 1; // অচেনা বার্তা
}
return handle;
}
let a = make_cart(1000);
let b = make_cart(1000);
a(1, 1040);
b(1, 180);
b(1, 190);
print(a(2, 0));
print(b(2, 0));
print(a(1, 0));
print(a(7, 0));
সত্যিকারের run, কোর্সের Haat reference দিয়ে (CPython 3.14.4): python haat.py run cart.haat আর python haat.py vm cart.haat দুটিই একই আউটপুট দেয়:
936
370
1040
-1
python haat.py dis-এর আউটপুটে make_cart-এর ভেতরে এই লাইনটি আছে: MAKE_CLOSURE 1 ; <fn handle> captures total, limit. অর্থাৎ handle তৈরির সময় compiler দুটি variable-কে “cell”-এ তুলে closure-এর সঙ্গে জুড়ে দেয়। প্রতিবার make_cart ডাকলে নতুন cell, তাই a আর b-এর খাতা আলাদা। নিচের stepper-এ দুটি object-এর অবস্থা লাইন ধরে দেখুন।
14let a = make_cart(1000);15let b = make_cart(1000);16a(1, 1040);17b(1, 180);18b(1, 190);19print(a(2, 0));20print(b(2, 0));21print(a(1, 0));22print(a(7, 0));
| a: total | |
| b: total | |
| limit |
- দুটি object তৈরি।
make_cartদুবার চলল, প্রতিবার নিজেরtotalআরlimit-এর cell বানাল।aআরbদুটি আলাদা closure; একই কোড, আলাদা অবস্থা। এটিই object-এর “পরিচয়”। - a-কে বার্তা 1.
handle-এর ভেতরেtotal = total + xচলল; closure variable reference হিসেবে ধরে, তাই বদলটি a-এর cell-এ থেকে গেল: 1040. b-এর খাতায় কিছুই হয়নি। - b-কে দুটি বার্তা। 180, তারপর 190 যোগ হয়ে b-এর total 370. দুই object-এর অবস্থা এখন আলাদা।
- a-কে বার্তা 2. 1040 ≥ 1000, তাই ১০% ছাড়: 1040 − 104 = 936 ছাপা হলো। বার্তা 2 অবস্থা বদলায় না, শুধু পড়ে।
- b-কে বার্তা 2. 370 < 1000, তাই ছাড় নেই, 370 ছাপা হলো। একই বার্তা, অবস্থাভেদে আলাদা উত্তর।
- a-কে বার্তা 1, x = 0. যোগ করার কিছু নেই, শুধু বর্তমান total ফেরত আসে: 1040. ছাড়টি অবস্থায় বসানো হয়নি, তাই total এখনো 1040.
- অচেনা বার্তা 7.
handleকোনো শাখায় মেলেনি, তাই −1. Smalltalk এমন ক্ষেত্রে “message not understood” error দেয়; আমাদের হাতে বানানো object নিজেই ঠিক করেছে কী করবে। বাইরের কোনো কোডtotal-এ সরাসরি পৌঁছাতে পারেনি।
এই ছোট উদাহরণে OOP-এর তিনটি মূল উপাদানই আছে: পরিচয় (দুটি আলাদা cart), লুকানো অবস্থা (বাইরে থেকে total নাম দিয়ে পৌঁছানো যায় না) আর বার্তা অনুযায়ী আচরণ। Closure আর object-এর এই মিল কাকতালীয় নয়; অংশ ৮-এ দেখবেন compiler-এর ভেতরে দুটি প্রায় একই জিনিস। Closure-এর পুরো গল্প পর্ব ১৭-এ (Closure — lexical environment ধরে রাখা function).
২ · Class আর encapsulation — “private” আসলে কতটা গোপন
Haat-এর হাতে বানানো object-এ সমস্যা আছে: বার্তা একটি সংখ্যা, তাই compiler জানে না 7 একটি ভুল বার্তা। বেশির ভাগ OOP ভাষা তাই একটি class দেয়: একই ধরনের object-এর নকশা, যেখানে field আর method-এর নাম লেখা থাকে। এক class থেকে অনেক object (instance) বানানো যায়, ঠিক যেমন এক ছাঁচ থেকে অনেক পিঠা।
এবার মডিউলের বাজারঘর কাজটি Python-এ object-oriented ধাঁচে লিখি। অর্ডার হলো একটি Order object, যার ভেতরে জেলা আর লাইনের তালিকা লুকানো। ছাড়ের নিয়মও একটি object: base class Discount কোনো ছাড় দেয় না, আর তার subclass TenPercent নিজের apply লেখে। sum_for জানে না কোন নিয়ম আসবে; সে শুধু policy.apply(...) বার্তা পাঠায়।
class Discount: # base class: no discount
def apply(self, total): return total
class TenPercent(Discount): # subclass overrides apply
def __init__(self, limit): self.limit = limit
def apply(self, total):
return total - total // 10 if total >= self.limit else total
class Order:
def __init__(self, district, lines):
self._district = district # "_" = private by convention only
self._lines = list(lines) # (qty, unit) pairs
def district(self): return self._district
def total(self): return sum(q * u for q, u in self._lines)
orders = [Order("Dhaka", [(2, 520)]), Order("Sylhet", [(3, 150)]),
Order("Dhaka", [(1, 180), (2, 95)]), Order("Dhaka", [(2, 650)])]
def sum_for(orders, district, policy): # works with ANY Discount
return sum(policy.apply(o.total()) for o in orders
if o.district() == district)
print("Dhaka, 10% over 1000:", sum_for(orders, "Dhaka", TenPercent(1000)))
print("Dhaka, no discount: ", sum_for(orders, "Dhaka", Discount()))
t = TenPercent(1000)
print("found apply in:", next(c.__name__ for c in type(t).__mro__
if "apply" in vars(c)))
print("found limit in: instance dict", vars(t))
print("__mro__:", [c.__name__ for c in TenPercent.__mro__])
o = orders[0]
o._lines.append((5, 1)) # nothing stops this in Python
print("after poking a private field:", o.total())আসল আউটপুট (ব্রাউজারের Python):
Dhaka, 10% over 1000: 2476
Dhaka, no discount: 2710
found apply in: TenPercent
found limit in: instance dict {'limit': 1000}
__mro__: ['TenPercent', 'Discount', 'object']
after poking a private field: 1045
ঢাকার তিনটি অর্ডারের মোট 1040, 370 আর 1300. ছাড়ের নিয়মে 936 + 370 + 1170 = 2476; ছাড় ছাড়া 2710. sum_for-এর একটি অক্ষরও না বদলে শুধু অন্য নিয়ম-object দিয়ে আলাদা ফল এল: এটিই polymorphism. তৃতীয় আর চতুর্থ লাইন দেখায় Python কোথায় খুঁজেছে: limit আছে object-এর নিজের dictionary-তে, আর apply আছে class TenPercent-এ। শেষ লাইনটি সতর্কবার্তা: Python-এ _lines শুধু একটি রীতি, “ছোঁবেন না”; বাইরের কোড চাইলে লাইন যোগ করে মোট 1040 থেকে 1045 বানাতে পারে।
তাহলে “private” মানে কী? উত্তরটি ভাষাভেদে আলাদা, আর এখানে AI assistant প্রায়ই এক ভাষার নিয়ম সব ভাষায় চাপায়। নিচের টেবিলে চারটি ভাষার নিয়ম, প্রতিটি সেই ভাষার নির্দিষ্ট version-এর জন্য:
| ভাষা | লেখা | কে আটকায়, কখন | ফাঁক |
|---|---|---|---|
| C++20 | private: | compiler, compile-এর সময়; access-এর নিয়ম class ধরে, object ধরে নয় | memory-তে field আছেই; pointer দিয়ে ছোঁয়া undefined behavior-এর দিকে যায় |
| Java 21 | private | compiler, আবার JVM-ও class load-এর সময় যাচাই করে | reflection (setAccessible), যদিও module system অনেক ক্ষেত্রে আটকায় |
| Python 3.14 | _x, __x | কেউ না; _x শুধু রীতি, __x-এর নাম বদলে _Cls__x হয় (name mangling) | সব কিছুই পৌঁছানো যায় |
| JavaScript (ES2022+) | #x | engine, চলার সময়; class-এর বাইরে #x লেখাই syntax error | সত্যিকারের গোপন; closure দিয়েও একই গোপনীয়তা পাওয়া যায় |
শিক্ষাটি গুরুত্বপূর্ণ: encapsulation একটি নকশার ধারণা, আর ভাষা সেটি কতটা জোর করে আদায় করে, তা আলাদা প্রশ্ন। C++-এর private নিরাপত্তার দেয়াল নয়, ভুল এড়ানোর বেড়া। Haat-এর closure-object আর JavaScript-এর #x সত্যিকারের গোপন, কারণ নামটিই বাইরের scope-এ নেই। প্রতিটি ভাষায় class লেখার খুঁটিনাটি সেই ভাষার কোর্সে আছে: Python কোর্সের পর্ব ৩১ (class ও object).
৩ · Inheritance আর subtype polymorphism — নিয়ম formal-ভাবে
Inheritance দুটি আলাদা কাজ একসঙ্গে করে, আর এই দুটি আলাদা করে দেখাই এই অংশের মূল কথা। কোড পুনর্ব্যবহার: subclass base-এর field আর method পেয়ে যায়। Subtyping: subclass-এর object-কে base-এর জায়গায় ব্যবহার করা যায়। C++ আর Java-তে class TenPercent : Discount লিখলে দুটিই একসঙ্গে আসে। কিন্তু ধারণা দুটি স্বাধীন: Go-র interface বা Rust-এর trait কোড উত্তরাধিকার ছাড়াই subtyping-এর মতো ব্যবহার দেয়।
Subtyping লেখা হয় S <: T, পড়ুন “S হলো T-এর subtype”: যেখানে T-এর মান চাওয়া হয়, সেখানে S-এর মান দিলেও নিরাপদ। Typing judgment Γ ⊢ e : τ-এর অর্থ “পরিবেশ Γ-এ expression e-এর type τ” (পর্ব ০৩-এ প্রথম দেখেছেন, পর্ব ৩৪-এ বিস্তারিত)। Subtyping যোগ করে মাত্র একটি নিয়ম, যার নাম subsumption:
T-Sub বলে: e-এর type S প্রমাণ করা গেলে, আর S যদি T-এর subtype হয়, তাহলে e-কে T হিসেবেও ধরা যায়। তাই sum_for(..., TenPercent(1000)) type-এর দিক থেকে ঠিক: TenPercent <: Discount. এখান থেকে দুটি আলাদা type পাওয়া যায়, আর পরীক্ষায় প্রশ্নটি প্রায়ই এখান থেকেই আসে:
- Static type: compiler যা দেখে। C++-এর
sum_for-এpol-এর static typeconst Discount&. - Dynamic type: চলার সময় আসল object-এর class. প্রথম ডাকে
TenPercent, দ্বিতীয় ডাকেDiscount.
Static type ঠিক করে কোন বার্তা পাঠানো বৈধ (Discount-এ apply আছে, তাই pol.apply ঠিক)। Dynamic type ঠিক করে কোন কোড চলবে। দ্বিতীয় কাজটির নাম dynamic dispatch, আর এটিকে এক বাক্যে নিয়ম হিসেবে লেখা যায়:
ধরুন o-এর dynamic class C, আর mro(C) = [C, C1, C2, …] হলো C আর তার পূর্বপুরুষদের খোঁজার সারি (single inheritance-এ সারিটি শুধু parent-এর শিকল)। তাহলে o.m(v1, …, vn) চালানো মানে: সারির প্রথম যে class D-তে m সংজ্ঞায়িত, সেই D.m-এর শরীর চালানো, যেখানে self (বা this) = o আর parameter = v1, …, vn. কোনো class-এ m না পেলে runtime error (Python-এ AttributeError); static typing থাকলে compiler আগেই নিশ্চিত করে যে এমন হবে না।
দুটি শব্দ গুলিয়ে যায়, তাই এখানেই আলাদা করি। Method overriding মানে subclass একই method নতুন করে লেখে; কোনটি চলবে তা ঠিক হয় চলার সময়, dynamic type দেখে। Function overloading মানে একই নামের কয়েকটি function, parameter-এর type বা সংখ্যা আলাদা; কোনটি চলবে তা compiler ঠিক করে compile-এর সময়, argument-এর static type দেখে। Overriding হলো subtype polymorphism, overloading হলো ad hoc polymorphism; তৃতীয় রূপ parametric (generics). তিনটির তুলনা পর্ব ৩৬-এ (Polymorphism — parametric, ad hoc আর subtype).
ভাষাভেদে ব্যতিক্রম: C++-এ method default-ভাবে non-virtual; virtual না লিখলে static type অনুযায়ী ডাকা হয়, dynamic dispatch হয় না। Java-তে instance method default-ভাবে virtual (final, private আর static বাদে)। Python আর JavaScript-এ সব method-এর খোঁজ চলার সময় হয়। “OOP-এ সব method virtual” কথাটি তাই C++-এর জন্য ভুল।
Java আর C++-এ এই বিষয়গুলো হাতে-কলমে আছে Java কোর্সের পর্ব ২০-এ (polymorphism আর dynamic dispatch) আর C++ কোর্সের পর্ব ২৫-এ (polymorphism ও virtual ফাংশন). এই কোর্সের প্রশ্ন অন্য: compiler এটি বানায় কীভাবে?
৪ · Dynamic dispatch-এর ভেতরে — vtable আর vptr
নিয়ম ৮.২ অনুযায়ী প্রতিটি ডাকে class-এর সারি ধরে নাম খুঁজতে হয়। C++ বা Java-র মতো statically typed ভাষায় compiler এই খোঁজটি আগেই সেরে রাখে। প্রতিটি class-এর জন্য সে একটি টেবিল বানায়, যার নাম vtable (virtual table): সেই class-এর প্রতিটি virtual method-এর জন্য একটি ঘর, তাতে আসল function-এর ঠিকানা। প্রতিটি object-এর শুরুতে থাকে একটি লুকানো pointer, vptr, যা নিজের class-এর vtable দেখায়। Method-এর নাম এখন একটি সংখ্যা (vtable-এর ঘর নম্বর), যা compile-এর সময়েই জানা।
প্রথমে একই বাজারঘর কাজ C++-এ, ব্রাউজার থেকে Wandbox-এ (GCC) চালিয়ে। শেষ লাইনে sizeof দেখাবে vptr-এর জায়গা:
#include <cstdio>
#include <string>
#include <utility>
#include <vector>
using ll = long long; using Lines = std::vector<std::pair<ll, ll>>; // (qty, unit)
struct Discount { // base class: no discount
virtual ll apply(ll t) const { return t; }
virtual ~Discount() = default;
};
struct TenPercent : Discount { // overrides apply
ll limit;
explicit TenPercent(ll l) : limit(l) {}
ll apply(ll t) const override { return t >= limit ? t - t / 10 : t; }
};
class Order { // fields are private
std::string district_; Lines lines_;
public:
Order(std::string d, Lines ls) : district_(std::move(d)), lines_(std::move(ls)) {}
bool in(const std::string& d) const { return district_ == d; }
ll total() const { ll s = 0; for (auto [q, u] : lines_) s += q * u; return s; }
};
ll sum_for(const std::vector<Order>& os, const char* d, const Discount& pol) {
ll sum = 0;
for (const Order& o : os) if (o.in(d)) sum += pol.apply(o.total()); // virtual call
return sum;
}
struct Plain { ll x; }; struct WithVirtual { virtual void f() {} ll x; };
int main() {
std::vector<Order> os = {{"Dhaka", {{2, 520}}}, {"Sylhet", {{3, 150}}},
{"Dhaka", {{1, 180}, {2, 95}}}, {"Dhaka", {{2, 650}}}};
printf("Dhaka, 10%% over 1000: %lld\n", sum_for(os, "Dhaka", TenPercent(1000)));
printf("Dhaka, no discount: %lld\n", sum_for(os, "Dhaka", Discount()));
printf("sizeof Plain=%zu WithVirtual=%zu TenPercent=%zu\n",
sizeof(Plain), sizeof(WithVirtual), sizeof(TenPercent));
}আসল আউটপুট (একই কোড নিজের যন্ত্রে Zig 0.17.1-এর Clang 22.1.8 দিয়ে, x86-64-এর জন্য -Wall -Wextra সহ compile করে চালানো, কোনো warning ছাড়া; ব্রাউজারের Run বোতাম কোডটি Wandbox-এর GCC-তে পাঠায়, যেখানে ৬৪-বিট Linux-এ একই সংখ্যা প্রত্যাশিত):
Dhaka, 10% over 1000: 2476
Dhaka, no discount: 2710
sizeof Plain=8 WithVirtual=16 TenPercent=16
Python-এর মতোই 2476 আর 2710. এবার আকার: একটি long long-এর Plain ৮ byte, কিন্তু একই field-এর সঙ্গে একটি virtual function যোগ করলেই ১৬ byte. বাড়তি ৮ byte হলো vptr. TenPercent-এরও ১৬: vptr আর limit. Virtual function যতগুলোই থাকুক, object-এ vptr একটিই; বাড়ে শুধু class-এর vtable, যা সব object ভাগ করে নেয়। Order-এ কোনো virtual function নেই, তাই তাতে vptr নেই। (এই সংখ্যাগুলো এই ABI-র; C++ standard vtable বা আকার বাধ্য করে না।)
Layout নিজের চোখে দেখতে সত্যিকারের Clang চালাই: PyPI-র ziglang 0.17.1 প্যাকেজ (MIT licence), যার ভেতরের Clang 22.1.8 (Apache-2.0 with LLVM exception). Target x86-64 Linux, অর্থাৎ Itanium C++ ABI, যা GCC আর Clang দুজনেই এই platform-এ মানে। -Xclang -fdump-vtable-layouts flag vtable ছাপে; আউটপুট ছেঁটে:
$ zig c++ -std=c++20 -O0 -fno-sanitize=undefined -S \
-target x86_64-linux-gnu -Xclang -fdump-vtable-layouts \
bazar.cpp -o bazar.s
Vtable for 'TenPercent' (5 entries).
0 | offset_to_top (0)
1 | TenPercent RTTI
-- (Discount, 0) vtable address --
-- (TenPercent, 0) vtable address --
2 | ll TenPercent::apply(ll) const
3 | TenPercent::~TenPercent() [complete]
4 | TenPercent::~TenPercent() [deleting]
প্রথম দুটি ঘর বিশেষ: offset_to_top (multiple inheritance-এ object-এর শুরু খুঁজতে) আর RTTI (চলার সময়ের type তথ্য, dynamic_cast আর typeid-এর জন্য)। “vtable address” লেখাটি দেখায় vptr কোথায় নির্দেশ করে: ঘর ২-এ, অর্থাৎ apply-এর ঘরে। Destructor-এর দুটি ঘর ABI-র নিয়ম: একটি শুধু ধ্বংস করে, অন্যটি memory-ও ফেরত দেয়। Discount-এর vtable একই আকারের, শুধু ঘর ২-এ Discount::apply (Clang long long-এর বদলে কোডের ছদ্মনাম ll ছাপে)। নিচের ছবিতে দুটি object আর তাদের vtable:
ছবি ৮.১ — দুটি object, দুটি vtable
ওপরে object-এর memory (byte offset), নিচে তার class-এর vtable. vptr নির্দেশ করে vtable-এর apply-এর ঘরে।
-fdump-record-layouts-simple আর -fdump-vtable-layouts থেকে: TenPercent-এ vptr offset 0-তে, limit offset 8-এ। বর্গবন্ধনীর সংখ্যা Clang-এর “VTable indices”, অর্থাৎ vptr থেকে কত ঘর দূরে। Destructor-গুলো virtual কারণ base-এ virtual ~Discount() আছে; vptr থাকায় খালি Discount object-ও ৮ byte.এবার সেই virtual call-এর আসল machine code. ছোট একটি function, ll pay(const Discount& d, ll t) { return d.apply(t); }, -O2-এ compile করে Clang 22.1.8 এই x86-64 assembly দিল (-masm=intel; frame pointer আর CFI-এর লাইন বাদ):
_Z3payRK8Discountx:
mov rax, qword ptr [rdi] ; rdi = &d → rax = d-এর vptr
mov rax, qword ptr [rax] ; vtable-এর ঘর [0] = apply-এর ঠিকানা
jmp rax ; TAILCALL: সেখানে লাফ
মাত্র দুটি memory পড়া আর একটি পরোক্ষ লাফ। System V x86-64 calling convention-এ প্রথম argument rdi-তে, দ্বিতীয়টি rsi-তে; C++-এ this লুকানো প্রথম argument, তাই rdi = object-এর ঠিকানা আর t থাকে rsi-তে, অছোঁয়া অবস্থায় callee-র হাতে যায়। Calling convention-এর বিস্তার পর্ব ৭১-এ। নিচের stepper-এ একই তিনটি নির্দেশ দুই ধরনের object দিয়ে চালান।
1pay(d, t): rdi = &d, rsi = t2mov rax, [rdi] ; vptr3mov rax, [rax] ; ঘর [0]4jmp rax ; লাফ5TenPercent::apply:6 cmp rsi, [rdi + 8] ; limit
| d (আসল) | |
| rsi | |
| rax |
- ডাক।
pay(ten, 1300):rdi-তেtenobject-এর ঠিকানা,rsi-তে 1300.payজানে শুধু static typeDiscount&; আসল type যেTenPercent, তা সে জানে না, জানার দরকারও নেই। - vptr পড়া। Object-এর প্রথম ৮ byte হলো vptr. Constructor-এ
TenPercentনিজের vtable-এর ঠিকানা এখানে বসিয়েছিল, তাইraxএখনTenPercent-এর vtable-এর ঘর [0]-এর ঠিকানা। - ঘর পড়া।
applyহলো vtable-এর ঘর [0]; compiler এই নম্বর compile-এর সময়েই জানত। ঘরের ভেতরের মানTenPercent::apply-এর ঠিকানা। - লাফ।
jmp rax: পরোক্ষ লাফ, গন্তব্য register-এ।callনয়, কারণ-O2দেখেছে এটিpay-এর শেষ কাজ (tail call), তাই ফেরার ঠিকানা আগের মতোই থাকে। - Override চলল।
TenPercent::apply[rdi + 8]থেকেlimit= 1000 পড়ে, ছবি ৮.১-এর offset 8. 1300 ≥ 1000, তাই 1300 − 130 = 1170 ফেরত। - একই কোড, Discount object. তিনটি নির্দেশ হুবহু এক, কিন্তু
Discountobject-এর vptr অন্য vtable দেখায়, যার ঘর [0]-এDiscount::apply. ফল 1300, কোনো ছাড় নেই। বাছাইটি হয়েছে ডেটা দিয়ে, কোনোifছাড়াই: dynamic dispatch এটুকুই।
একটি সূক্ষ্ম কিন্তু জরুরি কথা: optimizer যদি আসল type প্রমাণ করতে পারে, পরোক্ষ ডাক দরকারই নেই। TenPercent-কে final (আর কোনো subclass হতে পারবে না) ঘোষণা করে pay(const TenPercent& d, ll t) লিখলে একই Clang -O2-এ কোনো vptr পড়ে না; সরাসরি cmp rsi, qword ptr [rdi + 8] দিয়ে শুরু করে apply-এর শরীরটি ভেতরে বসিয়ে দেয়। একে বলে devirtualization; inlining-এর সঙ্গে মিলে এর আলোচনা পর্ব ৬৭-এ। Java-র JIT একই কাজ করে চলার সময়ের তথ্য দিয়ে, পর্ব ৬১-এ।
৫ · Class ছাড়া object — prototype আর delegation
Class-এর বিকল্প আছে। ১৯৮৭ সালে David Ungar আর Randall Smith-এর Self ভাষা প্রস্তাব করে: class থাকার দরকার কী? প্রতিটি object নিজের slot রাখে, আর যা নিজের কাছে নেই, তার খোঁজ পাঠায় আরেকটি object-এর কাছে, যার নাম prototype. এই খোঁজ পাঠানোকে বলে delegation. JavaScript (Brendan Eich, ১৯৯৫) এই ধারণা নিয়েছে; প্রতিটি object-এর একটি লুকানো সংযোগ থাকে তার prototype-এর দিকে, আর সেই শিকলের নাম prototype chain.
নতুন দোকানদার কোনো দামের প্রশ্নের উত্তর না জানলে বলেন, “দাঁড়ান, বড় ভাইকে জিজ্ঞেস করি”; বড় ভাই না জানলে যান মালিকের কাছে। প্রশ্নটি ওপরে যায়, কিন্তু টাকা নেওয়া হয় এই দোকানেই। Delegation-এ ঠিক তেমন: method খুঁজে পাওয়া যায় prototype-এ, কিন্তু চলার সময় this থাকে মূল object.
নিচের JavaScript-এ কোনো class নেই। Object.create(p) এমন একটি নতুন object বানায়, যার prototype p. whereIs হাতে শিকল ধরে হাঁটে আর বলে কোন object-এ property পাওয়া গেল। শেষে একই বাজারঘর হিসাব:
// No classes needed: objects delegate to other objects.
const discount = { apply(t) { return t; } };
const tenPercent = Object.create(discount); // tenPercent -> discount
tenPercent.apply = function (t) {
return t >= this.limit ? t - Math.trunc(t / 10) : t;
};
const policy = Object.create(tenPercent); // policy -> tenPercent
policy.limit = 1000;
function whereIs(obj, name) { // walk the chain by hand
const path = ["policy", "tenPercent", "discount", "Object.prototype"];
for (let o = obj, i = 0; o !== null; o = Object.getPrototypeOf(o), i++) {
if (Object.hasOwn(o, name)) return `${name}: found on ${path[i]} (hop ${i})`;
}
return `${name}: not found -> undefined`;
}
console.log(whereIs(policy, "limit"));
console.log(whereIs(policy, "apply"));
console.log(whereIs(policy, "toString"));
console.log(whereIs(policy, "district"));
const orders = [["Dhaka", [[2, 520]]], ["Sylhet", [[3, 150]]],
["Dhaka", [[1, 180], [2, 95]]], ["Dhaka", [[2, 650]]]];
const total = lines => lines.reduce((s, [q, u]) => s + q * u, 0);
const sumFor = (d, pol) => orders.filter(([dist]) => dist === d)
.reduce((s, [, lines]) => s + pol.apply(total(lines)), 0);
console.log("Dhaka, 10% over 1000:", sumFor("Dhaka", policy));
console.log("Dhaka, no discount: ", sumFor("Dhaka", discount));
class Ten { apply(t) { return t; } } // class = sugar over the same thing
console.log(typeof Ten, Object.getPrototypeOf(new Ten()) === Ten.prototype);আসল আউটপুট (ব্রাউজারের JavaScript; Node.js-এও একই):
limit: found on policy (hop 0)
apply: found on tenPercent (hop 1)
toString: found on Object.prototype (hop 3)
district: not found -> undefined
Dhaka, 10% over 1000: 2476
Dhaka, no discount: 2710
function true
তৃতীয় ভাষায়ও একই 2476 আর 2710. কোনো new নেই, কোনো class নেই, শুধু object আর তাদের মাঝের সংযোগ। apply পাওয়া গেছে এক ধাপ ওপরে, কিন্তু তার ভেতরের this.limit খোঁজা শুরু হয়েছে আবার policy থেকে, কারণ this = policy. শেষ লাইন দেখায় ES2015-এর class আসলে একটি function, আর new Ten()-এর prototype হলো Ten.prototype: class লেখার সুবিধা, ভেতরের কাঠামো সেই prototype chain-ই। বিস্তারে JavaScript কোর্সের পর্ব ২৫ (prototype আর prototype chain).
- policy
limit: 1000hop 0 - tenPercent
applyhop 1 - discount
applyhop 2 - Object.prototype
toString …hop 3 - null
—শিকলের শেষ
policy নিজের: limit tenPercent নিজের: apply discount নিজের: apply Object.prototype: toString, hasOwnProperty …
policy-তে limit আছে? হ্যাঁ → 1000
policy-তে apply? না tenPercent-এ apply? হ্যাঁ → tenPercent-এর apply (discount-এর apply আড়ালে পড়ল)
this.limit → policy-তে, hop 0 → 1000
1300 >= 1000 → 1300 - 130 = 1170
policy না, tenPercent না, discount না
Object.prototype-এ হ্যাঁ → String(policy)
= "[object Object]"
চারটি object-এর কোথাও নেই → null
ফল: undefined (error নয়)
- শিকলটি। চারটি object, প্রতিটি পরেরটির দিকে লুকানো সংযোগ রাখে, আর শেষে null. কোনো class নেই; “subclass” মানে শুধু “আরেকটি object, যার prototype এটি”।
- নিজের property.
limitpolicy-র নিজের, তাই প্রথম ধাপেই পাওয়া গেল, কোনো লাফ ছাড়াই। - এক ধাপ ওপরে।
applypolicy-তে নেই; খোঁজ গেলtenPercent-এ, পাওয়া গেল।discount-এরও একটিapplyআছে, কিন্তু খোঁজ প্রথম মিলেই থামে। Prototype-এর জগতে override মানে শুধু “শিকলের আগের দিকে একই নাম”। - Delegation-এর আসল কৌশল।
tenPercent-এরapplyচলছে, কিন্তুthis=policy. তাইthis.limit-এর খোঁজ আবার শিকলের শুরু থেকে: 1000, আর ফল 1170. একইapplyঅন্য limit-এর আরেকটি object-এ ভিন্ন ফল দেবে। - অনেক দূরে।
toStringতিন ধাপ ওপরে, সব সাধারণ object-এর সাধারণ পূর্বপুরুষObject.prototype-এ। তাই প্রায় সব JavaScript object-এ এটি “আছে”। - না পাওয়া। null পর্যন্ত গিয়েও
districtনেই; ফলundefined, error নয়। Python এখানেAttributeErrorদেয়, আর C++ বা Java compile-ই করে না: একই প্রশ্নে তিন ভাষার তিন উত্তর।
Prototype-এর সুবিধা নমনীয়তা: চলার সময় একটি object-এর prototype বা method বদলানো যায়, আর একটি object থেকেই আরেকটি “ধার” করা যায়। দাম হলো গতি আর নিশ্চয়তা: প্রতিটি খোঁজ শিকল ধরে, আর compiler আগে থেকে জানে না কোন object-এর আকার কী। “আরও গভীরে” বাক্সে দেখবেন engine কীভাবে এই খরচ কমায়। Dynamic ভাষার এই দিকগুলোর বড় আলোচনা পর্ব ১২-তে (Scripting আর dynamic ভাষা — duck typing, eval আর reflection).
৬ · Multiple inheritance, diamond আর C3 linearization
বাজারঘরে মাছ এমন একটি পণ্য, যা পচনশীলও (Perishable) আবার আমদানি করা (Imported)-ও হতে পারে। দুটি class থেকে একসঙ্গে উত্তরাধিকার নেওয়াকে বলে multiple inheritance. সমস্যা শুরু হয় যখন দুই parent-ই একই পূর্বপুরুষ Item থেকে আসে। Class-গাছটি দেখতে হীরার মতো, তাই নাম diamond problem:
Item
/ \
Perishable Imported
\ /
ImportedFish
দুটি প্রশ্ন ওঠে। (১) ডেটা: ImportedFish-এর object-এ Item-এর field একবার থাকবে না দুবার? C++-এ সাধারণ inheritance-এ দুবার থাকে, আর Item-এর একটি field-এর নাম ধরে ডাকলে compiler “ambiguous” error দেয়; একবার রাখতে লিখতে হয় class Perishable : virtual public Item, যার নাম virtual inheritance, আর দাম আরও জটিল layout আর vtable-এ বাড়তি offset. (২) Method: দুই parent-ই একই method override করলে কোনটি চলবে? Java ১৯৯৫ সাল থেকে class-এর জন্য multiple inheritance রাখেনি, শুধু interface-এর জন্য; Java 8-এ interface-এ শরীরসহ default method আসার পর একই সংঘাত হলে নিয়ম হলো: class-এর নিজের method জেতে, তারপর বেশি নির্দিষ্ট interface, আর তবুও দ্বিধা থাকলে class-কে নিজে override করতে হয়, নইলে compile error.
Python অন্য পথ নেয়: সব পূর্বপুরুষকে একটি সারিতে সাজায়, যার নাম method resolution order (MRO), আর নিয়ম ৮.২ অনুযায়ী সেই সারি ধরে খোঁজে। প্রশ্ন হলো সারিটি কীভাবে বানানো হবে। Python 2.3 থেকে নিয়মটি C3 linearization, যা Kim Barrett ও সহলেখকেরা ১৯৯৬ সালে Dylan ভাষার জন্য প্রস্তাব করেন (“A Monotonic Superclass Linearization for Dylan”, OOPSLA ১৯৯৬)।
Class C-এর parent B1, …, Bn (লেখার ক্রমে) হলে
L[C] = C + merge(L[B1], …, L[Bn], [B1, …, Bn]), আর parent না থাকলে L[C] = [C].
merge: তালিকাগুলোর প্রথম উপাদানগুলো (head) বাঁ থেকে দেখুন। প্রথম যে head অন্য কোনো তালিকার লেজে (tail, অর্থাৎ প্রথমটি বাদে বাকি অংশে) নেই, সেটি ফলে যোগ করুন আর সব তালিকা থেকে মুছুন। সব তালিকা খালি হলে শেষ। কোনো head-ই যোগ্য না হলে কোনো সংগত সারি নেই: error.
কেন এই অদ্ভুত নিয়ম? দুটি শর্ত রক্ষা করতে। Local precedence order: class ImportedFish(Perishable, Imported)-এ লেখা ক্রম, অর্থাৎ Perishable আগে, সারিতেও থাকবে। Monotonicity: একটি parent-এর নিজের সারির ক্রম subclass-এর সারিতে বদলাবে না। নিচের block-এ C3 হাতে লেখা, তারপর Python-এর নিজের __mro__-এর সঙ্গে মেলানো, তারপর একটি অসংগত গাছ:
def c3(cls, bases, trace=False): # bases: dict name -> list of parents
if not bases[cls]: return [cls]
seqs = [c3(b, bases) for b in bases[cls]] + [list(bases[cls])]
out = [cls]
while any(seqs):
seqs = [s for s in seqs if s]
for s in seqs: # first head not in any tail
head = s[0]
if not any(head in t[1:] for t in seqs): break
else:
raise TypeError(f"no consistent MRO for {cls}")
if trace: print(f" {head:11}<- " + " | ".join(" ".join(t) for t in seqs))
out.append(head)
seqs = [t[1:] if t[0] == head else t for t in seqs]
return out
H = {"object": [], "Item": ["object"], "Perishable": ["Item"],
"Imported": ["Item"], "ImportedFish": ["Perishable", "Imported"]}
print("C3 by hand:")
mro = c3("ImportedFish", H, trace=True)
print(" ->", mro)
class Item: pass
class Perishable(Item): pass
class Imported(Item): pass
class ImportedFish(Perishable, Imported): pass
print("Python: ", [c.__name__ for c in ImportedFish.__mro__])
H["Bad"] = ["Item", "Perishable"]
for who, make in [("hand", lambda: c3("Bad", H)),
("Python", lambda: type("Bad", (Item, Perishable), {}))]:
try: make()
except TypeError as e: print(f"{who}: TypeError: {e}")আসল আউটপুট (ব্রাউজারের Python):
C3 by hand:
Perishable <- Perishable Item object | Imported Item object | Perishable Imported
Imported <- Item object | Imported Item object | Imported
Item <- Item object | Item object
object <- object | object
-> ['ImportedFish', 'Perishable', 'Imported', 'Item', 'object']
Python: ['ImportedFish', 'Perishable', 'Imported', 'Item', 'object']
hand: TypeError: no consistent MRO for Bad
Python: TypeError: Cannot create a consistent method resolution order (MRO) for bases Item, Perishable
প্রতিটি trace লাইনে বাঁয়ে যে class নেওয়া হলো, ডানে সেই মুহূর্তের তালিকাগুলো। দ্বিতীয় লাইনটিই আসল শিক্ষা: প্রথম তালিকার head Item, কিন্তু সে দ্বিতীয় তালিকার লেজে আছে (Imported-এর পরে), তাই অপেক্ষা করতে হলো; নেওয়া হলো Imported. ফলে Item দুই সন্তানের পরে এল, হীরার নিচের দিক আগে। হাতের লেখা সারি Python-এর __mro__-এর সঙ্গে হুবহু মেলে। শেষ দুই লাইন: class Bad(Item, Perishable) চায় Item আগে, কিন্তু Perishable নিজেই চায় Item-এর আগে থাকতে; দুটি শর্ত একসঙ্গে মানা অসম্ভব, তাই দুজনেই TypeError.
নিচের stepper-এ একই merge ধাপে ধাপে। জায়গা বাঁচাতে নামগুলো ছোট: F = ImportedFish, P = Perishable, Im = Imported, I = Item, o = object.
1L[F] = F + merge(L[P], L[Im], [P, Im])2head দেখুন, বাঁ থেকে3head কোনো tail-এ? → পরের তালিকা4না হলে নিন, সব তালিকা থেকে মুছুন5সব খালি → শেষ
| তালিকা | |
| বাছাই | |
| ফল |
- শুরু। L[P] = P I o আর L[Im] = Im I o (প্রত্যেকের একটিই parent, তাই সরল শিকল), সঙ্গে parent-দের লেখার ক্রম P Im. ফলে প্রথমে F নিজে।
- P নেওয়া। প্রথম head P; P কোনো তালিকার লেজে নেই (তৃতীয় তালিকায় সে head). নেওয়া হলো, আর যেখানে head ছিল সেখান থেকে মোছা হলো।
- I অপেক্ষা করে। প্রথম তালিকার head এখন I, কিন্তু I আছে দ্বিতীয় তালিকা Im I o-এর লেজে: Im-কে I-এর আগে আসতে হবে। তাই পরের তালিকা দেখা হলো; head Im, কোনো লেজে নেই, নেওয়া হলো।
- I নেওয়া। এখন দুই তালিকাতেই I head, কোনো লেজে নেই। Item তার দুই সন্তানের পরে এল: হীরার মিলনবিন্দু নিচের সব পথের পরে।
- o নেওয়া। বাকি শুধু object; নেওয়া হলো, সব তালিকা খালি।
- ফল। F P Im I o, Python-এর
ImportedFish.__mro__-এর সঙ্গে হুবহু এক। এই সারিতেlabel()খুঁজলে প্রথমে F, তারপর P;super()-ও এই সারি ধরে “পরের” class-এ যায়, parent-এ নয়।
C3-এর দুটি গুণ একটি ছোট প্রমাণে দেখানো যায়। এটি merge-এর একটি সাধারণ ধর্ম থেকে আসে।
merge সফল হলে, কোনো ইনপুট তালিকায় x যদি y-এর আগে থাকে, তাহলে ফলেও x থাকবে y-এর আগে। ফলে L[C]-তে প্রতিটি L[Bi]-এর ক্রম রক্ষা পায় (monotonicity), আর parent-দের লেখার ক্রমও (local precedence).
প্রমাণ। (১) একটি উপাদান h নেওয়া হয় শুধু তখন, যখন h কোনো তালিকার লেজে নেই। তাই যে যে তালিকায় h আছে, সবগুলোতে h তখন head. (২) নেওয়ার পর h সেই সব তালিকার শুরু থেকে মোছা হয়; অর্থাৎ প্রতিটি তালিকা শুধু সামনে থেকে খরচ হয়, মাঝখান থেকে কিছু হারায় না। (৩) ধরুন কোনো তালিকা S-এ x আছে y-এর আগে। x যতক্ষণ S-এ আছে, y থাকে S-এর লেজে, তাই (১) অনুযায়ী y নেওয়া যায় না। কাজেই y নেওয়ার আগে x নেওয়া হয়ে গেছে। (৪) L[Bi] আর [B1, …, Bn] দুটিই merge-এর ইনপুট তালিকা, তাই দুটির ক্রমই ফলে রক্ষা পায়। ∎
উল্টো দিকটিও শিক্ষণীয়: Bad(Item, Perishable)-এ দুটি ইনপুট তালিকা পরস্পরবিরোধী ক্রম চায় (একটিতে Item আগে, অন্যটিতে Perishable আগে), তাই দাবি ৮.৪ অনুযায়ী এমন কোনো সারি থাকতেই পারে না, আর merge আটকে যাওয়াই সঠিক আচরণ। Python-এর দিক থেকে super() আর mixin-এর ব্যবহারিক আলোচনা আছে Python কোর্সের পর্ব ৩৩-এ (inheritance বনাম composition).
৭ · Liskov, variance আর composition — ভালো subtype কাকে বলে
T-Sub নিয়ম বলে subtype-এর মান base-এর জায়গায় বসানো type-এর দিক থেকে নিরাপদ। কিন্তু type ঠিক থাকলেই কি আচরণ ঠিক থাকে? ধরুন কেউ একটি কুপন নিয়ম লিখলেন:
class Coupon(Discount):
def apply(self, total):
if total < 500: raise ValueError("coupon needs at least 500")
return total - 50
Type-এর হিসাবে Coupon একটি Discount; Python বা কোনো type checker কিছু বলবে না। কিন্তু ঢাকার অর্ডারগুলোর মোট 1040, 370 আর 1300; sum_for-এ Coupon() দিলে 370-এ গিয়ে চালিয়ে পাওয়া ফল ValueError: coupon needs at least 500. যে কোড Discount-এর জন্য লেখা আর এতদিন ঠিক চলছিল, subclass আসায় ভেঙে গেল। এই ধরনের ভুলের জন্যই নীতিটি:
Barbara Liskov ১৯৮৭ সালের OOPSLA-র একটি keynote-এ (“Data Abstraction and Hierarchy”) ধারণাটি দেন; Liskov আর Jeannette Wing ১৯৯৪ সালের প্রবন্ধে (“A Behavioral Notion of Subtyping”) এটিকে প্রায় এভাবে লেখেন: ধরুন φ(x) এমন একটি ধর্ম, যা type T-এর প্রতিটি object x-এর জন্য প্রমাণ করা যায়। তাহলে T-এর subtype S-এর প্রতিটি object y-এর জন্যও φ(y) সত্য হওয়া উচিত।
Method-এর ভাষায় এর মানে: subtype-এর method (১) base-এর চেয়ে কড়া পূর্বশর্ত চাইবে না (preT ⇒ preS), (২) base-এর চেয়ে দুর্বল প্রতিশ্রুতি দেবে না (postS ⇒ postT), (৩) base-এর invariant রক্ষা করবে।
এই নীতিকে Liskov Substitution Principle বলা হয়। Discount.apply-এর পূর্বশর্ত “যেকোনো total”, আর Coupon চায় “total ≥ 500”: পূর্বশর্ত কড়া হয়েছে, নিয়ম (১) ভাঙা। ঠিক করার দুটি পথ: হয় Coupon ছোট total-এ ছাড় না দিয়ে total-ই ফেরত দেবে (তখন সে একটি বৈধ subtype), নয়তো এটি আদৌ Discount নয়, আলাদা ধারণা।
Type-এর স্তরেও নীতিটির একটি অংশ যন্ত্র দিয়ে যাচাই করা যায়। Override করা method-এর type কেমন হলে নিরাপদ? উত্তর function type-এর subtyping নিয়মে:
লক্ষ করুন দিক উল্টো: ফেরত type একই দিকে (covariant: subtype-এর method আরও নির্দিষ্ট জিনিস ফেরত দিতে পারে), কিন্তু parameter-এর type উল্টো দিকে (contravariant: subtype-এর method আরও সাধারণ ইনপুট নিতে পারে, কড়া নয়)। এটি নিয়ম (১) আর (২)-এরই type-রূপ। Java আর C++ ফেরত type-এ covariance দেয় (Java 5 থেকে covariant return); parameter-এর type বদলালে সেটি override হয় না, overload হয়ে যায়। কিছু ভাষা parameter-এও covariance দেয়, যেমন Eiffel; তখন type checker চুপ থাকলেও চলার সময় type error সম্ভব, যা এই নিয়মের দাম দেখায়।
Composition, inheritance-এর চেয়ে প্রায়ই নিরাপদ
খেয়াল করেছেন, বাজারঘরের কোডে Order কখনো Discount-এর subclass নয়; ছাড়ের নিয়ম একটি আলাদা object, যা sum_for-এ পাঠানো হয়। এটিই composition: “অর্ডারের একটি ছাড়ের নিয়ম আছে”, “অর্ডার একটি ছাড়ের নিয়ম” নয়। ১৯৯৪ সালের “Design Patterns” বইয়ের (Gamma, Helm, Johnson, Vlissides) একটি বিখ্যাত পরামর্শ: class inheritance-এর চেয়ে object composition বেছে নিন।
কারণ inheritance subclass-কে base-এর ভেতরের খুঁটিনাটির সঙ্গে বেঁধে ফেলে। Base-এ একটি নিরীহ বদল, যেমন একটি method অন্যটিকে ডাকা শুরু করল, এমন subclass ভাঙতে পারে যা কেউ ছোঁয়নি; এর নাম fragile base class সমস্যা। C++-এ base-এ একটি field যোগ করলে subclass-এর layout বদলায়, তাই পুরোনো compile করা কোড নতুন library-র সঙ্গে আর মেলে না। Composition-এ দুটি object শুধু public বার্তা দিয়ে কথা বলে, তাই একটির ভেতর বদলালে অন্যটি টের পায় না। Go আর Rust-এর মতো নতুন ভাষা তাই class inheritance রাখেইনি: Go-তে struct embedding আর interface, Rust-এ trait.
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন সাধারণ।
১. Overriding আর overloading-এর পার্থক্য? Overriding চলার সময় dynamic type দেখে বাছাই হয়; overloading compile-এর সময় argument-এর static type দেখে।
২. Virtual function থাকলে object-এর আকার বাড়ে কেন? প্রতিটি object-এ একটি vptr লাগে (৬৪-বিট system-এ সাধারণত ৮ byte); vtable class-প্রতি একটি, object-প্রতি নয়।
৩. Diamond problem আর তার সমাধান? দুই parent-এর সাধারণ পূর্বপুরুষ; C++-এ virtual inheritance, Java-তে class-এ multiple inheritance নেই, Python-এ C3 MRO.
৪. Liskov substitution এক লাইনে? Base-এর জায়গায় subtype বসালে program-এর সঠিকতা বদলাবে না: পূর্বশর্ত কড়া নয়, প্রতিশ্রুতি দুর্বল নয়।
৫. Constructor-এর ভেতর virtual function ডাকলে C++-এ কী হয়? তখনো object-এর vptr সেই constructor-এর class-এর vtable দেখায়, তাই subclass-এর override চলে না।
৮ · Compiler-এর চোখে OOP — class থেকে record, method থেকে function
OOP-এর বেশির ভাগ গঠন compiler একটি ছোট মূল ভাষায় নামিয়ে আনে; একে বলে desugaring (পর্ব ৫৫-এ বিস্তারিত)। একটি statically typed, single inheritance-এর OOP ভাষার জন্য নামানোর ছক:
| OOP গঠন | নামানো রূপ | কে কখন করে |
|---|---|---|
| class-এর field | record (struct): শুরুতে vptr, তারপর base-এর field, তারপর নিজের | compiler, layout ঠিক করার সময় (পর্ব ২৫) |
method m | সাধারণ function, প্রথম parameter self: TenPercent_apply(self, t) | compiler; নাম mangling: _ZNK10TenPercent5applyEx |
virtual call o.m(a) | o->vptr[k](o, a), k = ঘর নম্বর | compiler ঘর ঠিক করে, CPU চলার সময় লাফ দেয় |
| non-virtual call | সাধারণ সরাসরি ডাক | compiler, inline-ও করতে পারে |
new C(…) | memory নেওয়া, vptr বসানো, constructor চালানো | runtime আর constructor |
Python-এর o.m | dictionary-র খোঁজ, MRO ধরে, প্রতি ডাকে | interpreter, চলার সময় (cache সহ) |
অংশ ১-এর closure-object এই ছকের সঙ্গে মিলিয়ে দেখুন। Closure = code pointer + ধরা variable-এর পরিবেশ; object = vptr (code pointer-এর টেবিল) + field. দুটিই “কিছু কোড, সঙ্গে নিজের ডেটা”। পার্থক্য হলো closure-এর code pointer একটি, object-এর অনেকগুলো (প্রতি method-এ একটি)। তাই একটি অনুবাদ অন্যটিকে অনুকরণ করতে পারে: Haat-এর handle একটি function দিয়ে অনেক বার্তা সামলেছে, আর Java-র lambda ভেতরে একটি method-এর object. Haat-এর interpreter-এ environment আর closure কীভাবে বানানো হয়, তা পর্ব ৫৭-এ (Environment আর closure-এর বাস্তবায়ন)।
আরও গভীরে: Dynamic ভাষায় প্রতিটি o.m-এ dictionary খোঁজা ধীর। L. Peter Deutsch আর Allan Schiffman ১৯৮৪ সালে Smalltalk-80-এর বাস্তবায়নে inline cache ব্যবহার করেন: ডাকের জায়গায় শেষবার দেখা class আর পাওয়া method মনে রাখা, যাতে একই class আবার এলে খোঁজ লাগে না। Urs Hölzle, Craig Chambers আর David Ungar ১৯৯১ সালে Self-এর জন্য এটিকে কয়েকটি class মনে রাখার polymorphic inline cache-এ বাড়ান, আর Self-এর “map” (একই আকারের object-এর ভাগ করা বিন্যাস) থেকেই আজকের JavaScript engine-গুলোর hidden class বা shape-এর ধারণা এসেছে। CPython 3.11 থেকেও bytecode-এর ভেতরে attribute খোঁজার জন্য এমন cache রাখে (PEP 659-এর specializing interpreter).
সবশেষে, Haat-এ কি class যোগ করা উচিত? এই কোর্সের Haat-এর বর্ধিত রূপগুলো (array, record, algebraic type) আসবে সেই পর্বগুলোতে, যেখানে দরকার; class তালিকায় নেই, আর তার একটি ভালো কারণ আছে। অংশ ১ দেখিয়েছে first-class function আর closure দিয়ে encapsulation পাওয়া যায়, আর পর্ব ২৪-এর algebraic data type আর pattern matching অনেক কাজে subclass-এর জায়গা নেয়। ভাষা নকশার এই আপস নিয়ে পর্ব ০৬-এর ভাষা নকশার লক্ষ্য আর আপস আবার পড়ে দেখতে পারেন।
৯ · AI-এর যুগে OOP-এর ধারণা যাচাই
“OOP-এর চারটি স্তম্ভ” জাতীয় প্রশ্নে AI assistant মুখস্থ উত্তর ভালোই দেয়। সমস্যা শুরু হয় নির্দিষ্ট ভাষা আর নির্দিষ্ট আচরণের প্রশ্নে। এই বিষয়ে বারবার দেখা ভুল:
| AI-এর ভুল | কীভাবে ধরবেন |
|---|---|
| এক ভাষার নিয়ম সবার ঘাড়ে: “সব method virtual”, “private মানে কেউ ছুঁতে পারে না” | ভাষা আর version ধরে প্রশ্ন করা, আর ছোট program চালিয়ে দেখা (C++-এ virtual ছাড়া, Python-এ _x) |
| ভুল MRO: “Python depth-first খোঁজে” (Python 2-এর পুরোনো classic class-এর নিয়ম) | Cls.__mro__ ছাপিয়ে দেখা; হাতে C3 হিসাব করে মেলানো |
বানানো vtable layout বা sizeof, যেমন “প্রতি virtual function-এ object ৮ byte বাড়ে” | sizeof ছাপানো; Clang-এর -fdump-record-layouts আর -fdump-vtable-layouts চালানো, target লিখে |
| বানানো compiler flag বা assembly, যা আসল আউটপুটের সঙ্গে মেলে না | নিজে -S চালিয়ে মেলানো, compiler-এর নাম, version আর -O লেভেল লিখে |
| “Refactor” করে subclass বানানো, যা Liskov ভাঙে বা অর্থ বদলায় | পুরোনো আর নতুন কোড একই ইনপুটে চালিয়ে মেলানো (differential test), সীমার মান দিয়ে |
AI-কে শিক্ষকের বদলে যাচাইযোগ্য সঙ্গী বানাতে এমন প্রশ্ন করুন, যার উত্তর আপনি নিজে চালিয়ে মেলাতে পারবেন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।
প্র ০১Simula-র class না Smalltalk-এর message: “আসল” OOP কোনটি? C++ আর Java কোন ঐতিহ্যের?
OOP-এর দুটি শিকড়, আর দুটির জোর আলাদা জায়গায়। নরওয়ের Norwegian Computing Center-এ Ole-Johan Dahl আর Kristen Nygaard simulation লেখার জন্য Simula বানান; Simula 67 আনে class, object, subclass আর virtual procedure. তাঁদের লক্ষ্য ছিল বাস্তব জগতের জিনিস (জাহাজ, গ্রাহক, লাইন) program-এ মডেল করা। Simula-তে class একটি type, আর virtual procedure-এর ডাক compile-এর সময়ের কাঠামো দিয়ে সাজানো। এই ধারা থেকে এসেছে C++ (Bjarne Stroustrup নিজেই Simula-র প্রভাবের কথা বলেছেন) আর পরে Java: class = type, inheritance = subtyping, virtual call = vtable.
Xerox PARC-এ Alan Kay-এর দল Smalltalk বানায় (Smalltalk-72 থেকে Smalltalk-80 পর্যন্ত)। সেখানে সংখ্যা, class, এমনকি code block-ও object, আর সব কাজ হয় বার্তা পাঠিয়ে; কোন বার্তার কোন অর্থ, তা ঠিক হয় চলার সময়। Kay পরে বহুবার বলেছেন, তাঁর কাছে OOP-এর মূল কথা ছিল messaging, লুকানো অবস্থা আর late binding; class আর inheritance গৌণ। এই ধারার উত্তরসূরি Objective-C, Ruby, আর কিছুটা Python ও JavaScript. “Object-oriented” নামটি Kay-এর দেওয়া বলে সাধারণত উল্লেখ করা হয়, যদিও শব্দটির প্রথম ব্যবহার নিয়ে ঐতিহাসিকদের মধ্যে আলোচনা আছে।
দুই ধারার পার্থক্য এই পর্বেই দেখেছেন। C++-এ অজানা method ডাকলে compile হয় না; Python-এ AttributeError, JavaScript-এ undefined, আর Smalltalk-এ object নিজেই “message not understood” বার্তা পায় এবং চাইলে সেটি সামলাতে পারে। অংশ ১-এর Haat closure-object Smalltalk-এর ধারণার কাছাকাছি: বাইরের কোড শুধু বার্তা পাঠায়, আর অচেনা বার্তা object নিজে সামলায় (−1 ফেরত দিয়ে)।
তাহলে “আসল” OOP কোনটি? প্রশ্নটি অনেকটা “আসল বাংলা কোনটি, ঢাকার না চট্টগ্রামের” ধরনের। দুটিই বৈধ রূপ, আর প্রতিটির আপস আছে: static ধারা আগে ভুল ধরে আর দ্রুত চলে, dynamic ধারা নমনীয় আর চলার সময় বদলানো যায়। পরীক্ষায় উত্তর দেওয়ার সময় তাই ভাষার নাম বলে উত্তর দিন। দুই ভাষার জন্ম আর তারিখের পুরো ইতিহাস পর্ব ০২-এ (প্রোগ্রামিং ভাষার ইতিহাস আর পরিবার).
মূল উপলব্ধি: OOP একটি নয়, দুটি ঘনিষ্ঠ ঐতিহ্য: class-কেন্দ্রিক (Simula → C++, Java) আর message-কেন্দ্রিক (Smalltalk → Objective-C, Ruby). কোনো দাবি শুনলে জিজ্ঞেস করুন, কোন ঐতিহ্যের কোন ভাষার কথা হচ্ছে।
প্র ০২Java class-এর multiple inheritance বাদ দিল, তবু Java 8-এ default method এনে আবার diamond-এর দরজা খুলল কেন?
১৯৯৫ সালে Java-র নকশাকারেরা C++-এর অভিজ্ঞতা দেখেছিলেন: multiple inheritance-এ diamond, virtual inheritance-এর জটিল layout, আর কোন constructor কে ডাকবে তার কঠিন নিয়ম। তাঁরা একটি সরল আপস বেছে নেন। Class-এর জন্য একটিই parent, যাতে ডেটা আর constructor-এর শিকল সবসময় সরল রেখা। কিন্তু interface যত খুশি, কারণ তখন interface-এ শুধু method-এর নাম আর type থাকত, কোনো কোড বা field নয়। “একই নামের method দুই interface-এ” তখন কোনো সমস্যাই নয়, কারণ শরীর একটিই, class-এর নিজের।
সমস্যা এল প্রায় দুই দশক পরে। Java 8 (২০১৪) lambda আর stream আনল, আর Collection-এর মতো পুরোনো interface-এ নতুন method (যেমন stream(), forEach) যোগ করা দরকার হলো। কিন্তু interface-এ একটি নতুন abstract method যোগ করলে পৃথিবীর সব পুরোনো বাস্তবায়ন compile হওয়া বন্ধ করত, কারণ তারা নতুন method লেখেনি। এটি ভাষা নকশার একটি পরিচিত আপস: backward compatibility. সমাধান default method: interface নিজেই একটি শরীর দেয়, আর পুরোনো class কিছু না বদলেই সেটি পায়।
কিন্তু শরীর এলে diamond ফিরে আসে: দুই interface একই নামের default method দিলে class কোনটি পাবে? Java-র নিয়ম তিন ধাপের: প্রথমে class বা superclass-এর নিজের method জেতে (“class wins”); তারপর যে interface অন্যটির subinterface, সে বেশি নির্দিষ্ট, তাই জেতে; তবুও দ্বিধা থাকলে compiler error দেয়, আর class-কে নিজে override করতে হয়, চাইলে A.super.m() লিখে একটি বেছে নিয়ে। লক্ষ করুন, ডেটার diamond এখনো নেই, কারণ interface-এ instance field নেই; শুধু আচরণের diamond, আর সেটি compile-এর সময়েই মীমাংসা হয়।
অন্য ভাষাগুলো অন্য পথে গেছে। Scala-র trait-এ linearization আছে (কিছুটা C3-এর মতো ধারণা)। Rust-এর trait-এ কোনো inheritance-এর শিকল নেই; একই নামের method দুই trait-এ থাকলে ডাকার জায়গায় কোন trait-এর, তা স্পষ্ট লিখতে হয়। Python সরাসরি পুরো multiple inheritance দেয় আর C3 দিয়ে সারি বানায়।
মূল উপলব্ধি: ভাষার নকশা স্থির থাকে না; নতুন প্রয়োজন (এখানে পুরোনো interface বাড়ানো) পুরোনো সিদ্ধান্তের দাম আবার সামনে আনে। Java ডেটার diamond এড়িয়ে শুধু আচরণের diamond নিয়েছে, আর সেটির মীমাংসা compiler-এর হাতে রেখেছে।
প্র ০৩Virtual call কি ধীর? তাহলে game engine বা compiler-এর মতো দ্রুত software-এও কেন এত virtual function?
অংশ ৪-এ সত্যিকারের Clang-এর আউটপুটে দেখেছেন, একটি virtual call মানে দুটি memory পড়া আর একটি পরোক্ষ লাফ। একটি সরাসরি ডাকের তুলনায় এটি সামান্য বেশি কাজ, কিন্তু খরচের বড় অংশ অন্য জায়গায়। প্রথমত, পরোক্ষ লাফের গন্তব্য CPU আগে থেকে জানে না, তাই branch predictor অনুমান করে; অনুমান ঠিক হলে খরচ খুব কম, ভুল হলে pipeline খালি করে আবার শুরু করতে হয় (Computer Architecture কোর্সে pipeline আর branch prediction দেখেছেন)। একই জায়গায় সবসময় একই class এলে predictor প্রায় সবসময় ঠিক থাকে।
দ্বিতীয় আর বড় খরচটি লুকানো: inlining বন্ধ হয়ে যাওয়া। Compiler যদি না জানে কোন function চলবে, সে শরীরটি ডাকের জায়গায় বসাতে পারে না, আর তাই constant folding বা loop-এর optimization-ও আটকে যায়। ছোট method (যেমন একটি getter) virtual হলে এই ক্ষতি তুলনায় বড়। তাই এই পর্বে দেখা devirtualization গুরুত্বপূর্ণ: final লিখে বা পুরো program দেখে (whole-program বা link-time optimization) compiler প্রমাণ করে কোনো subclass নেই, তখন virtual call সরাসরি ডাক, এমনকি inline হয়।
JIT compiler আরও এক ধাপ এগোয়। HotSpot JVM চলার সময় দেখে কোন class সত্যিই load হয়েছে (class hierarchy analysis), আর একটি ডাকের জায়গায় আসলে কোন class আসছে (profile). একটিই এলে সে অনুমান করে সরাসরি ডাক বা inline বসায়, আর পাশে একটি পাহারা রাখে; পরে নতুন subclass load হলে কোডটি বাতিল করে ধীর পথে ফেরে (deoptimization, পর্ব ৬১)। ফলে Java-র “সব method default virtual” নীতির খরচ বাস্তবে অনেকটাই মুছে যায়।
দ্রুত software-এ তাই নিয়ম হলো মাপা: কোথায় virtual call সত্যিই গরম loop-এর ভেতরে আর কোথায় নয়। প্রতিটি frame-এ একবার ডাকা একটি virtual update() নগণ্য; কোটি ছোট object-এর ওপর loop-এর ভেতরের virtual getter নয়। সেখানে C++ template (static polymorphism) বা ডেটাকে type অনুযায়ী আলাদা সারিতে রাখা ব্যবহার করা হয়। কোনো গতির দাবি করার আগে নিজের program নিজের যন্ত্রে মেপে দেখুন; অন্যের benchmark-এর সংখ্যা আপনার কোডের জন্য সত্য নাও হতে পারে।
মূল উপলব্ধি: virtual call-এর আসল দাম নির্দেশের সংখ্যা নয়, optimizer-এর অন্ধত্ব। Compiler বা JIT আসল type জানতে পারলে সেই দাম প্রায় শূন্যে নামে।
প্র ০৪Go আর Rust class inheritance রাখেনি। এটি কি OOP থেকে সরে আসা, না OOP-এর ভালো অংশটুকু রেখে দেওয়া?
অংশ ৩-এ দেখেছেন, inheritance দুটি কাজ একসঙ্গে করে: কোড পুনর্ব্যবহার আর subtyping. দুটি জুড়ে থাকায় একটি চাইলে অন্যটিও নিতে হয়। ধরুন আপনি শুধু Discount-এর একটি সহায়ক function পুনর্ব্যবহার করতে চান, কিন্তু subclass বানালে আপনার class-টি এখন সব জায়গায় Discount হিসেবে চলতে পারে, আর Liskov-এর সব প্রতিশ্রুতি রাখতে হয়। উল্টোভাবে, base-এর ভেতরের বদল subclass ভাঙতে পারে: fragile base class. ১৯৯৪ সালের “Design Patterns” বইয়ের পরামর্শ, inheritance-এর চেয়ে composition, এই অভিজ্ঞতারই সারাংশ।
Go (Google-এ Robert Griesemer, Rob Pike আর Ken Thompson-এর নকশা, ২০০৯ সালে প্রকাশিত) দুটি কাজ আলাদা করে দিয়েছে। পুনর্ব্যবহারের জন্য struct embedding: একটি struct আরেকটিকে ভেতরে রাখে, আর ভেতরের method বাইরে থেকে ডাকা যায়, কিন্তু এটি subtyping নয়। Subtyping-এর জন্য interface, যা নামে ঘোষণা করতে হয় না: কোনো type-এ দরকারি method থাকলেই সে interface মানে (structural typing). Rust-এর trait-এ type নিজে ঘোষণা করে কোন trait বাস্তবায়ন করছে, আর polymorphism দুই রূপে পাওয়া যায়: generic-এ compile-এর সময় (monomorphization, পর্ব ৩৭) আর dyn Trait-এ চলার সময়, যেখানে একটি “fat pointer” ডেটার ঠিকানার পাশে vtable-এর ঠিকানা রাখে। লক্ষ করুন, vtable এখানে object-এর ভেতরে নয়, pointer-এর পাশে।
তাহলে OOP-এর কী থাকল? Encapsulation (module-এর গোপনীয়তা), interface-এর মাধ্যমে polymorphism আর dynamic dispatch, সবই আছে। হারিয়েছে শুধু implementation inheritance: “base-এর কোড নাও, কিছু বদলাও”। অনেকে একে OOP-এর পরিত্যাগ নয়, বরং Kay-এর message-কেন্দ্রিক ধারণার কাছে ফেরা বলে দেখেন: object কী করতে পারে তা গুরুত্বপূর্ণ, কার বংশধর তা নয়। আবার বড় GUI framework বা game engine-এ inheritance-এর গাছ এখনো কাজের, কারণ সেখানে অনেক class সত্যিই একটি সাধারণ কাঠামো ভাগ করে।
এই পর্বের বাজারঘর কোডটি এই দর্শনের ছোট উদাহরণ: Order কারও subclass নয়, ছাড়ের নিয়ম আলাদা object, আর একমাত্র inheritance (TenPercent থেকে Discount) শুধু subtyping-এর জন্য, যেখানে Liskov-এর শর্ত মানা হয়েছে।
মূল উপলব্ধি: inheritance-কে দুই ভাগে ভাবুন: subtyping আর কোড পুনর্ব্যবহার। আধুনিক ভাষাগুলো প্রথমটি রেখেছে, দ্বিতীয়টি composition দিয়ে করায়; এটি OOP-এর মৃত্যু নয়, পরিমার্জন।
প্র ০৫Prototype-ভিত্তিক ভাষা কি class-ভিত্তিকের চেয়ে বেশি শক্তিশালী? JavaScript-এ ES2015-এর class এল কেন?
প্রকাশক্ষমতার দিক থেকে prototype class-কে অনুকরণ করতে পারে, আর উল্টোটাও কিছুটা সম্ভব। অংশ ৫-এ দেখেছেন JavaScript-এর class আসলে একটি function, আর তার method-গুলো Ten.prototype নামের একটি সাধারণ object-এ থাকে। অর্থাৎ class হলো একটি রীতি: “একটি object, যাকে নকশা হিসেবে ব্যবহার করব”। Self-এর নকশাকারেরা ১৯৮৭ সালে ঠিক এই যুক্তি দিয়েছিলেন: class আর instance-এর দুই স্তর দরকার নেই, শুধু object আর delegation যথেষ্ট, আর এতে ভাষার মূল অংশ ছোট হয়।
তাহলে ES2015-এ class কেন? কারণ বাস্তবে প্রায় সবাই prototype দিয়ে class-ই বানাচ্ছিল, আর প্রতিটি library নিজের মতো করে: constructor function, Child.prototype = Object.create(Parent.prototype), constructor ঠিক করা, super-এর জন্য আলাদা কৌশল। ভুলের সুযোগ অনেক, আর পড়তে কষ্ট। class একটি সাধারণ লেখার রূপ দিল, সঙ্গে কিছু সত্যিকারের নতুন নিয়ম: new ছাড়া class ডাকা যায় না, class-এর ভেতর strict mode, super সরাসরি, আর পরে #private field. ভেতরের কাঠামো সেই prototype chain-ই, তাই পুরোনো কোডের সঙ্গে মেলে।
গতির দিক থেকে prototype-এর খোলামেলা স্বভাব engine-এর জন্য কঠিন: যেকোনো object-এ যেকোনো সময় property যোগ বা মোছা যায়। তাই engine-গুলো Self-এর “map” ধারণা থেকে hidden class (বা shape) বানায়: একই ক্রমে একই property পাওয়া object-গুলো একটি shape ভাগ করে, আর inline cache সেই shape মনে রাখে। ফলে একই রকমভাবে বানানো object-এর ওপর কোড দ্রুত চলে; কিন্তু চলার সময় এলোমেলোভাবে property যোগ করলে বা prototype বদলালে engine-এর cache নষ্ট হয়, আর কোড ধীর হতে পারে। এর বিস্তারিত engine আর version ভেদে বদলায়, তাই নির্দিষ্ট দাবির আগে মেপে দেখা দরকার।
সুতরাং “বেশি শক্তিশালী” প্রশ্নের সৎ উত্তর: prototype বেশি নমনীয় আর মূল ধারণায় সরল, class বেশি অনুমানযোগ্য আর static বিশ্লেষণে সহজ। TypeScript-এর মতো tool class-ভিত্তিক লেখাকে type-এর দিক থেকে যাচাই করে, যা খোলা prototype-এর জগতে কঠিন।
মূল উপলব্ধি: class আর prototype দুটি আলাদা জগৎ নয়; JavaScript-এ class হলো prototype-এর ওপর একটি শৃঙ্খলা। নমনীয়তা আর অনুমানযোগ্যতার আপসে ভাষাগুলো বিভিন্ন জায়গায় দাঁড়ায়।
অনুশীলন
প্রথমটিতে কোড লিখতে হবে; বাকিগুলো ভুল খোঁজা, হিসাব আর আউটপুট অনুমান।
-
নিজের object system (বাস্তবায়ন): Python-এর
classব্যবহার না করে শুধু dictionary দিয়ে একটি ছোট object system লিখুন। Class হবে{"name", "parent", "methods"}, object হবে{"class": …, অন্য field}, আরsend(obj, msg, *args)নিয়ম ৮.২ অনুযায়ী parent-এর শিকল ধরে method খুঁজে চালাবে, না পেলেAttributeError. তারপরDiscountআরTenPercentবানিয়ে 1300 আর 370-এapplyচালান।def make_class(name, parent, methods): return {"name": name, "parent": parent, "methods": methods} def new(cls, **fields): return {"class": cls, **fields} def send(obj, msg, *args): c = obj["class"] while c is not None: # walk the parent chain if msg in c["methods"]: return c["methods"][msg](obj, *args) # self = obj c = c["parent"] raise AttributeError(f"message not understood: {msg}") Discount = make_class("Discount", None, {"apply": lambda self, t: t, "describe": lambda self: "policy " + self["class"]["name"]}) TenPercent = make_class("TenPercent", Discount, {"apply": lambda self, t: t - t // 10 if t >= self["limit"] else t}) p = new(TenPercent, limit=1000) print(send(p, "apply", 1300), send(p, "apply", 370), send(p, "describe"))চালিয়ে পাওয়া আউটপুট:
1170 370 policy TenPercent, আরsend(p, "refund")-এAttributeError: message not understood: refund. লক্ষ করুনdescribeপাওয়া গেছে parent-এ, কিন্তু তার ভেতরেরself["class"]হলোTenPercent, কারণ self = মূল object: অংশ ৫-এর delegation-এর মতোই। Method-কে দ্রুত করতে চাইলে প্রতিটি class-এ একটি “সমতল” dictionary আগে থেকে বানিয়ে রাখতে পারেন, যাতে parent-এর method-ও থাকে: সেটিই vtable-এর ধারণা, নামের বদলে dictionary-র key দিয়ে। -
ভুল খুঁজুন (Liskov আর variance): (ক) একজন একটি
FlashSale(Discount)লিখলেন, যারapplytotal 2000-এর বেশি হলে ঋণাত্মক সংখ্যা ফেরত দেয়, “গ্রাহককে টাকা ফেরত” বোঝাতে।Discount.apply-এর অলিখিত প্রতিশ্রুতি “ফল 0 থেকে total-এর মধ্যে”। কোন নিয়ম ভাঙল, আরsum_for-এর কোন ব্যবহারকারী ক্ষতিগ্রস্ত হবেন? (খ) Java-তেclass Discount { long apply(Order o) }আরclass TenPercent extends Discount { long apply(BigOrder o) }, যেখানেBigOrder extends Order. এটি কি override? কেন S-Arrow নিয়ম এটি নিষেধ করে?(ক) সংজ্ঞা ৮.৫-এর নিয়ম (২): subtype-এর প্রতিশ্রুতি (postS) base-এর প্রতিশ্রুতির (postT) চেয়ে দুর্বল হয়েছে, কারণ ফল এখন 0-এর নিচে যেতে পারে। যে কোড যোগফলকে “বিক্রির আয়” ধরে হিসাব রাখে বা ফলকে টাকার রসিদে ছাপে, সে এখন ঋণাত্মক রসিদ পাবে, অথচ তার কোড কেউ বদলায়নি। ঠিক করার পথ: টাকা ফেরতকে আলাদা ধারণা (আলাদা method বা object) বানানো,
apply-এর প্রতিশ্রুতি অটুট রেখে।(খ) না, এটি override নয়, overload. Java-তে override-এর জন্য parameter-এর type হুবহু মিলতে হয়; এখানে নতুন একটি
apply(BigOrder)তৈরি হলো, আরDiscount-এর reference দিয়েapply(order)ডাকলে base-এরapply(Order)-ই চলবে (@Overrideলিখলে compiler error দিয়ে ধরিয়ে দেয়)। S-Arrow বলে parameter-এ subtype-এর method আরও সাধারণ type নিতে পারে, কড়া নয়: (S1) -> S2 <: (T1) -> T2-এর জন্য দরকার T1 <: S1, অর্থাৎOrder <: BigOrder, যা মিথ্যা। Override হলেDiscount-এর reference দিয়ে একটি সাধারণOrderপাঠানো যেত, আরTenPercent-এর method এমন কিছু পেত যাBigOrderনয়: type safety ভাঙত। -
আউটপুট অনুমান করুন (C3 আর super): (ক) Python-এ
class O,class Cash(O),class Card(O),class Mobile(O),class Wallet(Cash, Card),class Gateway(Card, Mobile),class Checkout(Wallet, Gateway).Checkout.__mro__হাতে হিসাব করুন। (খ) অংশ ৬-এর হীরায় প্রতিটি class-এlabel()আছে:Itemফেরত দেয়"Item", আর বাকিরা নিজের নাম (ImportedFish-এর বেলায়"Fish"), তারপর">", তারপরsuper().label().ImportedFish().label()আরPerishable().label()কী দেবে?(ক) L[Wallet] = Wallet Cash Card O object; L[Gateway] = Gateway Card Mobile O object. তারপর merge(Wallet Cash Card O object │ Gateway Card Mobile O object │ Wallet Gateway): Wallet নেওয়া; Cash নেওয়া (কোনো লেজে নেই); Card প্রথম তালিকার head, কিন্তু দ্বিতীয় তালিকার লেজে আছে, তাই অপেক্ষা; Gateway নেওয়া; এবার Card নেওয়া; তারপর Mobile (O তখনো দ্বিতীয় তালিকায় Mobile-এর পরে লেজে); তারপর O, object. ফল:
['Checkout', 'Wallet', 'Cash', 'Gateway', 'Card', 'Mobile', 'O', 'object']Python 3.14-এ চালিয়ে হুবহু এই তালিকা পাওয়া গেছে।
(খ)
super()parent-এ নয়, object-এর MRO-তে পরের class-এ যায়।ImportedFish-এর MRO F P Im I o, তাইPerishable-এর ভেতরেরsuper()যায়Imported-এ,Item-এ নয়:Fish>Perishable>Imported>Item. কিন্তু শুধুPerishable()-এর MRO P I o, তাই একই কোড দেয়Perishable>Item. দুটি ফলই চালিয়ে মেলানো। একইsuper()-এর অর্থ বদলায় object-এর আসল class অনুযায়ী: এটিও dynamic dispatch-এর একটি রূপ, আর এর জন্যই প্রতিটি class-এরlabelএকবারই চলেছে। -
Layout আর vtable হিসাব করুন: x86-64 Linux-এ (Itanium C++ ABI,
int৪ byte):
(ক)struct Rider { virtual int fee(int km) const { return 30 + 10 * km; } virtual int rating() const { return 4; } int id; }; struct Express : Rider { int fee(int km) const override { return 50 + 15 * km; } virtual int eta(int km) const { return 2 * km; } int zone; };sizeof(Rider)আরsizeof(Express)কত? প্রতিটি field কোন offset-এ? (খ)Express-এর vtable-এর ঘরগুলো ক্রমে লিখুন। (গ)Rider& r = e; r.fee(3)কত ফেরত দেবে?Clang 22.1.8-এর
-fdump-record-layoutsআর-fdump-vtable-layoutsচালিয়ে পাওয়া (ছেঁটে):0 | struct Rider 0 | (Rider vtable pointer) 8 | int id | [sizeof=16, dsize=12, align=8] 0 | struct Express 0 | struct Rider (primary base) 0 | (Rider vtable pointer) 8 | int id 12 | int zone | [sizeof=16, dsize=16, align=8] Vtable for 'Express' (5 entries). 0 | offset_to_top (0) 1 | Express RTTI 2 | int Express::fee(int) const 3 | int Rider::rating() const 4 | int Express::eta(int) const(ক) দুটিই ১৬ byte.
Rider: vptr (৮) +id(৪) = ১২, কিন্তু alignment ৮ হওয়ায় শেষে ৪ byte padding, তাই ১৬। চমকটিExpress-এ:zoneবসেছে offset 12-এ, ঠিকRider-এর সেই padding-এ। Itanium ABI এমন base-এর শেষের padding পুনর্ব্যবহার করতে দেয়, তাই নতুন field যোগ হলেও আকার বাড়েনি। (Alignment আর padding-এর পুরো নিয়ম পর্ব ২৫-এ।)(খ) নিয়মটি: base-এর ঘরগুলো একই ক্রমে আগে (override করলে ঘরে নতুন function), তারপর subclass-এর নতুন virtual function. তাই
feeঘর [0]-এExpress::fee,ratingঘর [1]-এ base-এর নিজেরটি (override হয়নি), আর নতুনetaঘর [2]-এ। একই ঘর নম্বর রাখায়Rider&দিয়ে লেখা কোডExpressobject-এও ঠিক ঘর পায়।(গ) dynamic type
Express, তাইExpress::fee: 50 + 15 × 3 = 95 (base-এরটি হলে 60 হতো)।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমC++-এ pol.apply(t) একটি virtual call. চলার সময় ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- object-এর ঠিকানা লুকানো প্রথম argument (this) হিসেবে register-এ রাখা
- object-এর শুরু থেকে vptr পড়া
- vtable থেকে apply-এর ঘরের function ঠিকানা পড়া
- সেই ঠিকানায় পরোক্ষ ডাক বা লাফ
- override করা function this দিয়ে নিজের field পড়ে ফল ফেরত দেয়
x86-64 Linux-এ GCC দিয়ে struct P { long long x; }; আর struct V { virtual void f() {} long long x; }; compile করলে sizeof(P) আর sizeof(V) কত?
- ৮ আর ৮
- ৮ আর ১৬
- ৮ আর ২৪, কারণ vtable object-এর ভেতরে থাকে
- ১৬ আর ১৬
Python-এ class Item, class Perishable(Item), class Imported(Item), class ImportedFish(Perishable, Imported). ImportedFish.__mro__-এর ক্রম কী?
- ImportedFish, Perishable, Item, Imported, object
- ImportedFish, Imported, Perishable, Item, object
- ImportedFish, Perishable, Imported, Item, object
- object, Item, Perishable, Imported, ImportedFish
JavaScript-এ const a = {x: 1}; const b = Object.create(a); b.y = 2; চালানোর পর b.x, Object.hasOwn(b, "x") আর b.z-এর মান কী?
- 1, false, undefined
- 1, true, undefined
- undefined, false, undefined
- 1, false, TypeError
Method overriding আর function overloading-এর পার্থক্য নিয়ে কোন কথাটি সঠিক?
- Overloading চলার সময় ঠিক হয়, overriding compile-এর সময়
- দুটি একই জিনিসের দুই নাম
- Overloading শুধু subclass-এ সম্ভব
- Overriding-এ object-এর dynamic type, overloading-এ argument-এর static type বাছাই ঠিক করে
Base class-এর apply(total) যেকোনো total নেয় আর 0 থেকে total-এর মধ্যে মান ফেরত দেয়। Subclass-এর কোন apply Liskov substitution মানে?
- total < 500 হলে exception দেয়, নইলে total − 50
- যেকোনো total নেয়, total ≥ 2000 হলে ২০% ছাড়, নইলে total
- বড় total-এ ঋণাত্মক মান ফেরত দেয়, “টাকা ফেরত” বোঝাতে
- total-এর সঙ্গে ডেলিভারি চার্জ 60 যোগ করে ফেরত দেয়
C++-এ struct D { virtual long long apply(long long t) const; }; আর long long pay(const D& d, long long t) { return d.apply(t); }. Clang -O2-এ x86-64-এর জন্য pay-এর মূল নির্দেশগুলো কী ধরনের?
- একটি সরাসরি
call D::apply - method-এর নাম দিয়ে একটি dictionary-তে খোঁজ
- দুটি memory পড়া (vptr, তারপর vtable-এর ঘর) আর একটি পরোক্ষ লাফ
- d-এর type দেখে if-else-এর শিকল
Function type-এর subtyping নিয়ম (S-Arrow) অনুযায়ী কোনটি সত্য, যেখানে BigOrder <: Order?
(Order) -> Int <: (BigOrder) -> Int(BigOrder) -> Int <: (Order) -> Int- দুটি function type একে অপরের subtype
- Function type-এর মধ্যে subtyping সংজ্ঞায়িত নয়
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Object = পরিচয় + অবস্থা + আচরণ; বার্তা পেয়ে কোন কোড চলবে তা ঠিক করে গ্রহণকারী। Closure দিয়েও object বানানো যায়।
- Static type বলে কোন বার্তা বৈধ, dynamic type বলে কোন কোড চলবে; overriding চলার সময়, overloading compile-এর সময়।
- C++/Java-র virtual call = vptr পড়া → vtable-এর ঘর পড়া → পরোক্ষ লাফ; আসল type প্রমাণ হলে compiler devirtualize করে।
- Prototype-এর জগতে খোঁজ চলে prototype chain ধরে, আর this থাকে মূল object; Python-এ খোঁজ চলে C3 দিয়ে বানানো MRO ধরে।
- ভালো subtype আচরণেও base-এর প্রতিশ্রুতি রাখে (Liskov; parameter contravariant, ফেরত covariant); কোড পুনর্ব্যবহারে প্রায়ই composition নিরাপদ।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ০৯ · Functional programming — pure function, immutability আর higher-order functionপরবর্তী পর্বএকই বাজারঘর হিসাব, অবস্থা না বদলে।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্ব১৪টি মডিউলের পুরো মানচিত্র।
- পর্ব ০২ · প্রোগ্রামিং ভাষার ইতিহাস আর পরিবারইতিহাসSimula 67 আর Smalltalk-এর জন্ম, আর OOP-এর ধারণা কোন ভাষায় কীভাবে গেল।
- C++ প্রোগ্রামিং · পর্ব ২৫ · polymorphism ও virtual ফাংশনহাতে-কলমেvirtual, override, abstract class আর object slicing.
- JavaScript · পর্ব ২৫ · prototype আর prototype chainহাতে-কলমেconstructor function, class আর prototype-এর সম্পর্ক।
- Python · পর্ব ৩৩ · inheritance বনাম compositionনকশাsuper(), MRO আর কখন inheritance, কখন composition.