অ্যারে, রেকর্ড ও পয়েন্টার

class Memory:
    """একটি ফ্ল্যাট 'র মেমরি' সিমুলেশন -- প্রতিটি ইনডেক্স একটি মেমরি অ্যাড্রেস।"""
    def __init__(self, size=64):
        self.cells = [None] * size

    def write(self, address, value):
        self.cells[address] = value

    def read(self, address):
        return self.cells[address]


class Array:
    def __init__(self, memory, base_address, elem_size, length):
        self.memory = memory
        self.base_address = base_address
        self.elem_size = elem_size
        self.length = length

    def address_of(self, i):
        if not (0 <= i < self.length):
            raise IndexError(f"ইনডেক্স {i} সীমার বাইরে")
        return self.base_address + i * self.elem_size

    def __setitem__(self, i, value):
        self.memory.write(self.address_of(i), value)

    def __getitem__(self, i):
        return self.memory.read(self.address_of(i))


class Record:
    def __init__(self, memory, base_address, fields):
        # fields: [(name, size_in_units), ...] -- ডিক্লেয়ার করা ক্রমেই
        self.memory = memory
        self.base_address = base_address
        self.offsets = {}
        running_offset = 0
        for name, size in fields:
            self.offsets[name] = running_offset
            running_offset += size

    def address_of(self, field_name):
        return self.base_address + self.offsets[field_name]

    def set_field(self, field_name, value):
        self.memory.write(self.address_of(field_name), value)

    def get_field(self, field_name):
        return self.memory.read(self.address_of(field_name))


class Pointer:
    def __init__(self, memory, address):
        self.memory = memory
        self.address = address

    def dereference(self):
        return self.memory.read(self.address)


memory = Memory(size=64)

# --- Array: base=10, elem_size=4, length=5 ---
arr = Array(memory, base_address=10, elem_size=4, length=5)
values = [11, 22, 33, 44, 55]
for i, v in enumerate(values):
    arr[i] = v

expected_addr_3 = 10 + 3 * 4          # হাতে-হিসাব: base + i*elem_size
print(f"হাতে-হিসাব করা addr(3) = 10 + 3*4 = {expected_addr_3}")
print(f"কোডের হিসাব করা arr.address_of(3) = {arr.address_of(3)}")
assert arr.address_of(3) == expected_addr_3
assert arr[3] == 44
print(f"arr[3] = {arr[3]}  (প্রত্যাশিত 44)  ঠিকানা মিলেছে: {arr.address_of(3) == expected_addr_3}")

# --- Record: base=40, fields id(1), age(1), salary_cents(4) ---
rec = Record(memory, base_address=40, fields=[("id", 1), ("age", 1), ("salary_cents", 4)])
rec.set_field("id", 7)
rec.set_field("age", 30)
rec.set_field("salary_cents", 500000)

expected_addr_salary = 40 + (1 + 1)   # হাতে-হিসাব: base + sum(আগের ফিল্ডগুলোর সাইজ)
print(f"\nহাতে-হিসাব করা addr(salary_cents) = 40 + (1+1) = {expected_addr_salary}")
print(f"কোডের হিসাব করা rec.address_of('salary_cents') = {rec.address_of('salary_cents')}")
assert rec.address_of("salary_cents") == expected_addr_salary
assert rec.get_field("salary_cents") == 500000
print(f"rec.get_field('salary_cents') = {rec.get_field('salary_cents')}  ঠিকানা মিলেছে: {rec.address_of('salary_cents') == expected_addr_salary}")

# --- Pointer: array[3]-এর ঠিকানার দিকে নির্দেশ করা ---
ptr = Pointer(memory, address=arr.address_of(3))
print(f"\nptr.dereference() = {ptr.dereference()}  (arr[3] = {arr[3]}-এর সমান হওয়া উচিত)")
assert ptr.dereference() == arr[3]