Memory Management

What is Pointer?

1. পয়েন্টার হলো এমন একটা ভেরিয়েবল যা অন্য একটা ভেরিয়েবলের মেমোরি অ্যাড্রেস (Memory Address) জমা রাখে।

মনে করো, তোমার বন্ধুর নাম ‘আরিফ’। আরিফ একটা বাড়িতে থাকে।

• এখানে ‘আরিফ’ হলো Variable Value (যেমন ১০ বা ২০)।
• আর আরিফের বাড়ির ঠিকানা (যেমন: বাড়ি নং ৫০) হলো Memory Address।
• যে কাগজে তুমি এই ঠিকানাটা লিখে রেখেছ, সেই কাগজটাই হলো Pointer।

1. অ্যাড্রেস এবং ডি-রেফারেন্সিং (Address vs Dereferencing)

কোডে এটি বুঝতে দুটি চিহ্ন খুব গুরুত্বপূর্ণ:

• ১. & (Address of operator): এটি কোনো ভেরিয়েবলের ঠিকানা বের করে।
• ২. * (Dereferencing operator): এটি ওই ঠিকানায় কী ভ্যালু আছে তা বের করে আনে।

int x = 10;      // একটি সাধারণ ভেরিয়েবল
int *ptr = &x;   // ptr এখন x এর ঠিকানা (address) ধরে রেখেছে

cout << x;       // আউটপুট: 10
cout << ptr;     // আউটপুট: x এর মেমোরি অ্যাড্রেস (যেমন: 0x61ff08)
cout << *ptr;    // আউটপুট: 10 (ঠিকানা ধরে ভ্যালু বের করা)

মেমোরি লেআউট (The 4 Segments)

যেকোনো প্রসেস যখন মেমোরিতে লোড হয়, তখন সেটি মূলত ৪টি প্রধান ভাগে ভাগ হয়:

A. Code Segment (Text Segment):

এখানে তোমার লেখা আসল কোড বা ইনস্ট্রাকশনগুলো থাকে।

• এটি Read-only; অর্থাৎ প্রোগ্রাম চলার সময় তুমি নিজের কোড নিজে পরিবর্তন করতে পারবে না।
• এটি মেমোরির একদম নিচের দিকে থাকে।

B. Data Segment:

এখানে থাকে Global এবং Static ভেরিয়েবলগুলো। এটি আবার দুই ভাগ:

• Initialized Data: যেগুলোর ভ্যালু তুমি আগে থেকেই দিয়ে দিয়েছ (যেমন: int x = 10;)।
• BSS (Uninitialized): যেগুলোর ভ্যালু দাওনি, জাস্ট ডিক্লেয়ার করেছ (যেমন: int y;)।

C. Stack (Fast & Auto):

স্ট্যাক কাজ করে LIFO (Last In First Out) পদ্ধতিতে।

• এখানে লোকাল ভেরিয়েবল এবং ফাংশন কলগুলো থাকে।
• এটি ওপর থেকে নিচের দিকে বাড়ে।
• ফাংশন শেষ হওয়ার সাথে সাথে এর মেমোরি অটো ডিলিট হয়ে যায়।
• সিনিয়ররা কেন ফ্লেক্স করে? কারণ তারা জানে বেশি গভীরে ফাংশন কল (Recursion) করলে স্ট্যাক শেষ হয়ে Stack Overflow হবে।

D. Heap (The Dynamic Space):

হিপ হলো মেমোরির বিশাল একটা খালি জায়গা। এটি নিচ থেকে ওপরের দিকে বাড়ে।

• তুমি যখন new বা malloc দিয়ে মেমোরি নাও, তখন সেটা হিপ-এ যায়।
• এটি নিজে নিজে খালি হয় না। হয় তোমাকে নিজে হাতে ডিলিট করতে হবে (C/C++), নয়তো গারবেজ কালেক্টরের ওপর ভরসা করতে হবে (Java/Python)।

২. User Space vs Kernel Space

এটি সিস্টেম লেভেলের কনসেপ্ট:

• Kernel Space: মেমোরির এই অংশটি সংরক্ষিত থাকে ওএস (OS)-এর জন্য। তোমার কোড সরাসরি এখানে ঢুকতে পারে না।
• User Space: তোমার অ্যাপ্লিকেশন বা কোড এই অংশে চলে। যখন তোমার কোড হার্ডওয়্যার বা নেটওয়ার্ক ব্যবহার করতে চায়, তখন সে একটা System Call করে কার্নেল স্পেসে রিকোয়েস্ট পাঠায়।

৩. Garbage Collection (GC) - পর্দার আড়ালে সাফাই অভিযান

সিনিয়ররা জানে কখন গারবেজ কালেক্টর ট্রিগার হয়।

• কীভাবে কাজ করে? এটি হিপ মেমোরি মনিটর করে। যখন দেখে কোনো অবজেক্টের সাথে প্রোগ্রামের কোনো সরাসরি কানেকশন বা “Reference” নেই, তখন সে বুঝে নেয় এই অবজেক্টটি এখন আবর্জনা। সে তখন সেটাকে মেমোরি থেকে মুছে দেয়।

• ঝামেলা কোথায়? গারবেজ কালেকশন যখন চলে, তখন অনেক সময় প্রোগ্রাম সামান্য সময়ের জন্য থমকে যায় (একে বলে Stop-the-world ইভেন্ট)। হাই-পারফরম্যান্স সিস্টেম বানানোর সময় ইঞ্জিনিয়াররা এমন কোড লেখে যাতে GC-কে কম কাজ করতে হয়।

৪. Memory Leak: বড় ইঞ্জিনিয়ারদের মাথাব্যথা

মেমোরি লিক তখন হয় যখন তুমি হিপ মেমোরিতে জায়গা নিয়েছ কিন্তু কাজ শেষ হওয়ার পর সেটাকে আর ছাড়োনি (Free করোনি)।

• ধরো, একটা লুপের ভেতর তুমি অবজেক্ট বানাচ্ছ কিন্তু সেগুলো কোথাও ব্যবহার করছ না, আবার ডিলিটও করছ না। একটা সময় তোমার র‍্যাম ফুল হয়ে যাবে এবং কম্পিউটার হ্যাং করবে।

একটা বাস্তব অ্যাপ্লিকেশনের সিনারিও দিয়ে মেমোরির প্রতিটি ইঞ্চি বুঝে নেওয়া যাক

// ১. Data Segment (Global variable)
int totalVisitors = 1000;

void calculateDiscount(int price) {
    // ২. Stack (Local variable)
    int discount = 10;

    // ৩. Heap (Dynamic memory allocation)
    int* finalPrice = new int;
    *finalPrice = price - discount;

    cout << *finalPrice;
}

int main() {
    calculateDiscount(500);
    return 0;
}

১. Code Segment (Text): তুমি যে if-else, cout, বা calculateDiscount ফাংশনটা লিখেছ, সেটার ইনস্ট্রাকশনগুলো এখানে থাকে। এটি Read-only। এখানে হাত দেওয়ার ক্ষমতা কারোর নেই।

২. Data Segment: এখানে তোমার totalVisitors = 1000ভেরিয়েবলটি থাকবে। এটি প্রোগ্রাম শুরু হওয়া থেকে শেষ হওয়া পর্যন্ত মেমোরি দখল করে রাখবে। কারণ এটি Global।

৩. Stack Memory (লোকাল জগতের রাজা): যখন main() থেকে calculateDiscount(500) কল হলো, তখন স্ট্যাকে একটা Stack Frame তৈরি হয়।

• price (৫০০) এবং discount (১০) এই স্ট্যাক ফ্রেমের ভেতরে থাকে।
• এই মেমোরি খুব ফাস্ট। কিন্তু সমস্যা হলো, ফাংশনটা শেষ হওয়া মাত্রই এই discount আর price ভেরিয়েবলগুলো মেমোরি থেকে ভ্যানিশ হয়ে যাবে।

৪. Heap Memory (অস্থায়ী বড় জায়গা): খেয়াল করো, আমরা লিখেছি new int। এটি মেমোরির একটা বিশাল খালি জায়গায় (Heap) একটা ছোট ঘর তৈরি করে।

• টুইস্ট: হিপ-এ তৈরি হওয়া সেই ঘরের কোনো নাম নেই, আছে শুধু একটা অ্যাড্রেস (যেমন: 0xABC)।
• স্ট্যাকে থাকা পয়েন্টার finalPrice এই 0xABC অ্যাড্রেসটাকে ধরে রাখে।

৫. User Space বনাম Kernel Space (বাস্তব উদাহরণ)

• User Space: তোমার ডিসকাউন্ট ক্যালকুলেশন কোডটি ইউজার স্পেসেই চলছে।
• Kernel Space: যখন তুমি cout দিয়ে স্ক্রিনে কিছু প্রিন্ট করতে চাইলে, তখন তোমার প্রোগ্রাম ওএস-কে (OS) রিকোয়েস্ট পাঠালো। ওএস তখন কার্নেল স্পেস থেকে মনিটরের ড্রাইভার ব্যবহার করে আউটপুট দেখালো। এই সুইচিংটাকে বলে Context Switching।

৬. Garbage Collection & Memory Leak (সিনিয়র লেভেল কনসেপ্ট)

উপরের কোডে new int দিয়ে হিপ-এ জায়গা নিয়েছি কিন্তু delete করিনি।

• C++ এ: প্রোগ্রাম শেষ হলেও হিপ-এর ওই জায়গাটা আটকে থাকবে। একেই বলে Memory Leak। সিনিয়ররা এখানে delete finalPrice; লিখে মেমোরি ফ্রি করে দেয়।
• Java/Python এ: যদি এই পয়েন্টারটা (Reference) কেউ আর ব্যবহার না করে, তবে Garbage Collector নিজে থেকেই এসে ওই হিপ-এর জায়গাটা পরিষ্কার করে দেবে। ___

🧠 Memory Layout of a Process

কম্পিউটার মেমোরিতে একটি প্রোগ্রাম কীভাবে জায়গা দখল করে এবং কাজ করে, তার একটি ভিজ্যুয়াল রিপ্রেজেন্টেশন নিচে দেওয়া হলো:

   High Address +---------------------------------------+

                |          Kernel Space (OS)            | <--- সিস্টেম কল ও হার্ডওয়্যার হ্যান্ডেল করে
                +---------------------------------------+

                |        Stack (🔽 নিচের দিকে বাড়ে)       | <--- লোকাল ভেরিয়েবল, ফাংশন আর্গুমেন্ট
                | (LIFO: Last In First Out)             |
                +---------------------------------------+

                |           Unused Memory Space         |
                |       (মেমোরি ফাঁকা থাকলে বাড়ে)         |
                +---------------------------------------+

                |        Heap (🔼 ওপরের দিকে বাড়ে)       | <--- Dynamic Memory (new, malloc)
                | (সবচেয়ে বড় এবং ফ্লেক্সিবল জায়গা)         |
                +---------------------------------------+

                |     Uninitialized Data (BSS)          | <--- ভ্যালু ছাড়া Global/Static (e.g., int x;)
                +---------------------------------------+

                |      Initialized Data Segment         | <--- ভ্যালুসহ Global/Static (e.g., int x=10;)
                +---------------------------------------+

                |      Code / Text Segment (Read-only)  | <--- তোমার আসল কোড (Binary instructions)
    Low Address +---------------------------------------+

```cpp
int global_var = 50;            // Data Segment (Initialized)
int uninitialized_var;          // BSS Segment

void myFunc() {
    int local_var = 10;         // Stack Memory
    int* h_ptr = new int(20);   // h_ptr থাকে Stack-এ, কিন্তু 20 থাকে Heap-এ
}

📍 মূল কনসেপ্ট (The Core Logic)

সহজ কথায়: Stack হচ্ছে মেমোরির একটি ছোট কিন্তু সুপার ফাস্ট ড্রয়ার, আর Heap হচ্ছে একটি বিশাল গুদাম ঘর।

১. Stack Memory (রেফারেন্স থাকে)

• এখানে থাকে Primitive Values (যেমন: int, boolean) এবং বড় ডাটার Reference (ঠিকানা)।
• এটি স্ট্যাটিক মেমোরি অ্যালোকেশন ব্যবহার করে।
• ফাংশন এক্সিকিউশন শেষ হওয়ার সাথে সাথে এর ডাটা অটোমেটিক ডিলিট হয়ে যায়।

২. Heap Memory (আসল ভ্যালু থাকে)

• এখানে থাকে Objects, Arrays, Functions এবং বড় ডাটা সেট।
• এটি ডাইনামিক মেমোরি অ্যালোকেশন ব্যবহার করে।
• এখানকার ডাটা ক্লিন করার জন্য Garbage Collector (GC) এর প্রয়োজন হয়।

#include <iostream>
using namespace std;
int main() {

    int x=5;
    int* p= &x;
    cout<< p;
    cout<< *p;

    return 0;
}

Variable Address Value +———+———–+———–+ | x | 0x101 | 5 | <– x এর নিজের মান ৫ +———+———–+———–+ | p | 0x202 | 0x101 | <– p এর ভেতর x এর ঠিকানা (0x101) +———+———–+———–+

• &x Address of x ভেরিয়েবলটি মেমোরির কোন ঠিকানায় আছে?
• int* p Pointer Declaration p নামের একটা পয়েন্টার বানাও যা ঠিকানা সেভ করবে।
• p Pointer Value p এর ভেতর জমানো ঠিকানাটা (Address) দেখাও।
• *p Dereferencing এই ঠিকানায় যে ভ্যালুটা লুকুয়ে আছে তা বের করে আনো।

Swap Function using Pointers

#include <iostream>
using namespace std;

// এখানে *x এবং *y হলো পয়েন্টার যারা আসল ঠিকানাকে পয়েন্ট করছে
void swap(int* x, int* y) {
    int temp = *x; // x-এর ঠিকানায় যে ভ্যালু (১০) আছে তা temp-এ রাখো
    *x = *y;       // y-এর ঠিকানায় থাকা ভ্যালু (২০) কে x-এর ঠিকানায় বসাও
    *y = temp;     // temp-এর ভ্যালু (১০) কে y-এর ঠিকানায় বসাও
}

int main() {
    int a = 10, b = 20;

    // &a এবং &b দিয়ে আমরা অরিজিনাল অ্যাড্রেস পাঠাচ্ছি
    swap(&a, &b);

    cout << "a: " << a << ", b: " << b; // আউটপুট: a: 20, b: 10
    return 0;
}

মেমোরির ভেতরে কী ঘটলো? (Step-by-Step)

• Main Stack: র‍্যামের স্ট্যাক মেমোরিতে a এর জন্য একটা ঘর (ঠিকানা: 0x101) আর b এর জন্য একটা ঘর (ঠিকানা: 0x102) তৈরি হলো।
• Function Call: তুমি যখন swap(&a, &b) করলে, তখন তুমি 10 বা 20 পাঠাওনি, পাঠিয়েছ 0x101 এবং 0x102 ঠিকানা দুটি।
• Pointer Logic:
• temp = *x মানে হলো “যাও 0x101 ঠিকানায় এবং যা পাও তা নিয়ে আসো” (অর্থাৎ ১০)।
• *x = *y মানে হলো “যাও 0x102 ঠিকানায়, সেখানে ২০ আছে। এখন ওই ২০-কে নিয়ে 0x101 ঠিকানায় বসিয়ে দাও।”
• Result: ফাংশন শেষ হওয়ার পর স্ট্যাক থেকে ফাংশনটি মুছে গেলেও, মেইন মেমোরির অরিজিনাল ঠিকানাগুলোতে ভ্যালুগুলো চিরতরে বদলে গেছে।

Double Pointer - int** p

সহজ কথায়, এটি হলো “পয়ন্টারের পয়েন্টার”।

• সাধারণ পয়েন্টার: একটি সাধারণ ভেরিয়েবলের ঠিকানা (Address) ধরে রাখে।
• ডাবল পয়েন্টার: একটি পয়েন্টার ভেরিয়েবলের নিজের যে ঠিকানা আছে, সেটা ধরে রাখে।

বাস্তব উদাহরণ: মনে করো, ‘আরিফ’ একটা বাড়িতে থাকে।

• ১. ভেরিয়েবল: আরিফ নিজে।
• ২. পয়ন্টার (p): একটা চিরকুট যাতে আরিফের বাড়ির ঠিকানা লেখা আছে।
• ৩. ডাবল পয়েন্টার (pp): আর একটা চিরকুট যাতে লেখা আছে— “প্রথম চিরকুটটা (পয়ন্টার p) আলমারির কোন ড্রয়ারে রাখা আছে।”

int x = 10;
int* p = &x;    // p এখন x এর ঠিকানা জানে
int** pp = &p;  // pp এখন p এর নিজের ঠিকানা জানে

cout << x;    // ১০
cout << *p;   // ১০ (x এর ভ্যালু)
cout << **pp; // ১০ (p এর কাছে গিয়ে তার ঠিকানায় থাকা x এর ভ্যালু)

কেন ডাবল পয়েন্টার লাগে?

• Dynamic 2D Array: তুমি যখন মেমোরিতে একটা টেবিল (Matrix) বানাতে চাও যেখানে রোগুলো আলাদা আলাদা সাইজের হতে পারে, তখন ডাবল পয়েন্টার ছাড়া উপায় নেই।
• পয়ন্টার পরিবর্তন করা: যদি তুমি ফাংশনের ভেতর থেকে মেইন ফাংশনের কোনো পয়ন্টারকেই অন্য কোথাও পয়েন্ট করাতে চাও (অরিজিনাল পয়েন্টার আপডেট), তখন ডাবল পয়েন্টার লাগে।

Const with Pointers

const মানে হলো “স্থির” বা যা পরিবর্তন করা যায় না। পয়েন্টারের সাথে এটি ৩ ভাবে কাজ করে এবং ইন্টারভিউতে এটি প্রচুর জিজ্ঞেস করা হয়:

Pointer to Constant (const int* p)

পয়ন্টার যাকে পয়েন্ট করছে (Value), তার মান বদলানো যাবে না। কিন্তু পয়েন্টার নিজে অন্য ঠিকানায় যেতে পারবে।

const int* p = &x;
// *p = 20;  <-- ভুল (মান বদলানো নিষেধ)
p = &y;      // ঠিক (অন্য ঠিকানায় যেতে পারবে)

Constant Pointer (int* const p)

পয়ন্টার যাকে পয়েন্ট করছে (Value), তার মান বদলানো যাবে না। কিন্তু পয়েন্টার নিজে অন্য ঠিকানায় যেতে পারবে।

const int* p = &x;
// *p = 20;  <-- ভুল (মান বদলানো নিষেধ)
p = &y;      // ঠিক (অন্য ঠিকানায় যেতে পারবে)

Constant Pointer (int* const p)

পয়ন্টার একবার যার ঠিকানা নিয়েছে, সে আর অন্য কোথাও যেতে পারবে না। কিন্তু সে যাকে পয়েন্ট করছে তার ভ্যালু বদলাতে পারবে।

int* const p = &x;
*p = 20;     // ঠিক (ভ্যালু বদলানো যাবে)
// p = &y;   <-- ভুল (ঠিকানা বদলানো নিষেধ)

Constant Pointer to Constant (const int* const p)

সবকিছু লক! না ভ্যালু বদলানো যাবে, না ঠিকানা।

const int* const p = &x;
// না ভ্যালু বদলাবে, না ঠিকানা।

মেমোরি ম্যাপ

Memory Level: [ x: 10 ] <— Address: 0x101 ^ | [ p: 0x101 ] <— Address: 0x202 (Simple Pointer) ^ | [ pp: 0x202 ] <— Address: 0x303 (Double Pointer)

Memory Leak

এটি ঘটে যখন তুমি Heap মেমোরিতে কোনো জায়গা দখল করো (যেমন: new বা malloc দিয়ে), কিন্তু কাজ শেষে তা আর মুক্ত (delete বা free) করো না।

• সহজ উদাহরণ: ধরো তুমি একটা হোটেলের রুম ভাড়া নিলে, কিন্তু চেক-আউট না করেই চলে আসলে। হোটেল মালিক মনে করবে রুমটা এখনও বুকড, তাই সে অন্য কাউকে তা দিতে পারবে না।
• ফলাফল: র‍্যাম (RAM) ধীরে ধীরে ভরে যেতে থাকে এবং এক সময় অ্যাপ্লিকেশনটি মেমোরির অভাবে ক্রাশ করে।

Dangling Pointer

তুমি মেমোরি মুক্ত করে দিয়েছ (delete করেছ), কিন্তু পয়েন্টার ভেরিয়েবলটির কাছে এখনও সেই পুরোনো ঠিকানাটা রয়ে গেছে।

• সহজ উদাহরণ: একটি বাড়ি ভেঙে ফেলা হয়েছে (মেমোরি ডিলিট), কিন্তু তোমার কাছে এখনও ওই বাড়ির ঠিকানাটা ডায়েরিতে লেখা আছে। এখন তুমি যদি ওই ঠিকানায় গিয়ে ঘরে ঢোকার চেষ্টা করো, তুমি আসলে এমন কোথাও পা দিচ্ছ যা এখন আর অস্তিত্বশীল নয়।

• ফলাফল: এর ফলে Segmentation Fault বা Undefined Behavior দেখা দেয়। (প্রোগ্রাম হুটহাট অদ্ভুত কাজ শুরু করে)।

Double Delete

এটি খুবই ভয়ংকর ভুল। একই মেমোরি পয়েন্টার বা ঠিকানাকে যদি তুমি দুইবার free বা delete করার চেষ্টা করো, তবেই এটি হয়।

• সহজ উদাহরণ: একটি রুম অলরেডি চেক-আউট করা হয়ে গেছে, তুমি আবার গিয়ে কাউন্টারে বললে “রুমটা চেক-আউট করো”। সিস্টেম তখন কনফিউজড হয়ে যায় এবং সাথে সাথে ক্রাশ করে।
• ফলাফল: আধুনিক কম্পাইলার এবং ওএস (OS) এটি দেখা মাত্রই সিকিউরিটি এবং স্ট্যাবিলিটির খাতিরে প্রোগ্রামটি সাথে সাথে বন্ধ বা Crash করে দেয়।