অ্যারে — একই রকম ডেটা পাশাপাশি সাজিয়ে রাখা

১ · ১০০ জন ছাত্রের নম্বর — ১০০টি ভ্যারিয়েবল?

ধরুন আপনার কলেজের একটি সেকশনে ১০০ জন ছাত্র। বোর্ড পরীক্ষার আগে টেস্ট পরীক্ষার নম্বর নিয়ে একটি প্রোগ্রাম লিখবেন — গড় কত, সর্বোচ্চ কে পেল, কতজন গড়ের ওপরে। এ পর্যন্ত যা শিখেছেন, তা দিয়ে শুরু করলে লিখতে হবে:

int mark1, mark2, mark3, mark4, mark5, /* … */ mark100;
total = mark1 + mark2 + mark3 + /* … আরও ৯৭টি … */ + mark100;

এটি শুধু বিরক্তিকর নয়, অবাস্তবও। কাল ছাত্র ১২০ জন হলে পুরো কোড নতুন করে লিখতে হবে। আর সবচেয়ে বড় সমস্যা: পর্ব ১২-এর লুপ দিয়ে mark1, mark2… একটির পর একটি ঘোরা যায় না, কারণ এগুলো ১০০টি আলাদা নাম — compiler-এর কাছে এদের মধ্যে কোনো সম্পর্ক নেই।

সমাধান হলো array (বাংলায় অনেকে বলেন “অ্যারে”) — একটি নাম, তার নিচে একই মাপের অনেকগুলো ঘর, একটির ঠিক পাশে আরেকটি। প্রতিটি ঘরকে বলে element, আর ঘরটি কত নম্বর, সেটিকে বলে index.

int marks[100];          /* ১০০টি int-এর ঘর, এক নামে */
marks[0] = 72;           /* প্রথম ঘর */
marks[99] = 58;          /* শেষ ঘর */
for (int i = 0; i < 100; i++) total += marks[i];

আসলে আপনি অ্যারে আগেই দেখেছেন। পর্ব ১৫-এ Fibonacci-র জন্য যে memo টেবিলে উত্তর লিখে রাখছিলাম — memo[2], memo[3]… — সেটি ছিল একটি অ্যারে। আর পর্ব ০২-এ পাঁচজন ছাত্রের নম্বরের তালিকা থেকে সর্বোচ্চ খোঁজার কাজটিও অ্যারের ওপরই হয়েছিল। এই পর্বে দেখব পর্দার পেছনে আসলে কী ঘটে।

২ · মেমরিতে অ্যারে — পাশাপাশি ঘর আর একটি ছোট সূত্র

পর্ব ০৬-এ দেখেছিলেন, প্রতিটি ভ্যারিয়েবল মেমরির কোনো একটি ঠিকানায় থাকে, আর int সাধারণত ৪ byte জায়গা নেয়। এখন int marks[5]; লিখলে compiler মেমরিতে একটানা ৫ × ৪ = ২০ বাইট জায়গা আলাদা করে রাখে — মাঝে কোনো ফাঁক নেই। একে বলে contiguous memory, অর্থাৎ “গায়ে গা লাগানো” জায়গা।

প্রথম ঘরটির ঠিকানাকে বলে base address. বাকি সব ঘরের ঠিকানা এখান থেকেই হিসাব করা যায়। কারণ ঘরগুলো সমান মাপের আর পাশাপাশি, তাই i নম্বর ঘরটি শুরু থেকে ঠিক i টি ঘর দূরে। নিচের ডায়াগ্রামে সহজ করার জন্য base address 1000 ধরা হলো (আসল ঠিকানা অনেক বড় সংখ্যা হয়)। “পরে” চাপুন আর প্রতিটি ধাপে হিসাবটি খেয়াল করুন:

iঠিকানা   ঘর          মান01000     marks[0]    7211004     marks[1]    8521008     marks[2]    6431012     marks[3]    9041016     marks[4]    5851020     ????        অ্যারের বাইরে

এই একটি লাইনই অ্যারের পুরো গল্প। sizeof এখানে ঘরের মাপ — int হলে সাধারণত ৪, double হলে ৮, char হলে ১. আপনি লেখেন marks[3], compiler সেটিকে এই গুণ-যোগের নির্দেশে বদলে দেয়। আপনাকে কখনো বাইট গুনতে হয় না, কিন্তু ভেতরে কী হচ্ছে জানলে পরের সব কিছু — pointer, string, cache — সহজ হয়ে যাবে।

গোনা কেন 0 থেকে

পর্ব ১২-এ কথা দিয়েছিলাম, এই পর্বে এর কারণ পরিষ্কার হবে। সূত্রটি আবার দেখুন: index আসলে “শুরু থেকে কত ঘর দূরে” — ইংরেজিতে offset. প্রথম ঘরটি শুরু থেকে শূন্য ঘর দূরে, তাই তার index 0. যদি 1 থেকে গোনা হতো, তাহলে প্রতিবার ঠিকানা বের করতে লাগত base + (i − 1) × 4 — প্রতিটি ঘর ছোঁয়ার আগে একটি বাড়তি বিয়োগ। ১৯৭০-এর দশকের ধীর কম্পিউটারে এটা ছিল অপচয়।

আরেকটি সুবিধা আছে, যা পর্ব ১২-এ half-open range নামে দেখেছেন: n টি ঘরের বৈধ index হলো 0 ≤ i < n. লুপের শর্ত i < n, ঘরের সংখ্যা n − 0 = n — কোনো বাড়তি ±1 নেই। Edsger Dijkstra ১৯৮২ সালের নোটে ঠিক এই যুক্তিই দিয়েছিলেন। তবে মনে রাখুন, এটি একটি নকশার সিদ্ধান্ত, প্রকৃতির নিয়ম নয় — Fortran, MATLAB ও Lua-তে গোনা 1 থেকে।

৩ · ঘোষণা, শুরুর মান আর দৈর্ঘ্য মাপা

অ্যারে ঘোষণা করতে লাগে তিনটি জিনিস: টাইপ, নাম, আর তৃতীয় বন্ধনীতে ঘরের সংখ্যা। শুরুর মান দিতে চাইলে দ্বিতীয় বন্ধনীতে কমা দিয়ে লিখুন। কয়েকটি নিয়ম একসাথে দেখে নিই:

অ্যারের দৈর্ঘ্য — sizeof দিয়ে মাপা

C-র অ্যারে নিজের দৈর্ঘ্য কোথাও লিখে রাখে না — মেমরিতে শুধু ঘরগুলোই থাকে। তবে যেখানে অ্যারেটি ঘোষণা করা হয়েছে, সেখানে compiler তার পুরো মাপ জানে। তাই এই কৌশল:

int marks[] = {72, 85, 64, 90, 58, 77};
int n = sizeof(marks) / sizeof(marks[0]);   /* 24 / 4 = 6 */

sizeof(marks) হলো পুরো অ্যারের বাইট (৬ × ৪ = ২৪), আর sizeof(marks[0]) একটি ঘরের বাইট (৪). ভাগ করলে ঘরের সংখ্যা। সুবিধা হলো, পরে তালিকায় একটি নম্বর যোগ করলে n নিজে থেকেই ঠিক হয়ে যায় — কোথাও “6” বদলাতে ভুলে যাওয়ার সুযোগ নেই। তবে সাবধান: এই কৌশল কাজ করে শুধু যেখানে অ্যারেটি ঘোষণা করা হয়েছে। ফাংশনে পাঠানোর পর এটি চুপচাপ ভুল উত্তর দেয় — অংশ ৬-এ দেখবেন কেন।

ঘরের সংখ্যা কী দিয়ে লিখবেন? প্রচলিত ও নিরাপদ পথ হলো একটি নির্দিষ্ট সংখ্যা, যেমন int marks[100];. C99 থেকে ভ্যারিয়েবল দিয়েও মাপ দেওয়া যায় (int marks[n];), কিন্তু বড় n হলে ফাংশনের সীমিত জায়গা (stack) ভরে যেতে পারে, আর C11-এ এই সুবিধাটি ঐচ্ছিক করা হয়েছে — সব compiler-এ নাও থাকতে পারে। চলার সময় মাপ ঠিক হলে সঠিক পথ dynamic memory, যা পর্ব ২০-এ আসবে।

৪ · সীমার বাইরে — যেখানে C পাহারা দেয় না

প্রথম ডায়াগ্রামের শেষ ধাপে দেখেছেন, marks[5] চাইলে CPU সূত্র মেনে 1020 ঠিকানায় চলে যায়। প্রশ্ন হলো, C কি একবারও যাচাই করে না যে 5 < 5 কি না? উত্তর: না। অ্যারের সীমার বাইরে পড়া বা লেখাকে বলে out-of-bounds access, আর C-র নিয়মে এর ফল undefined behavior — অর্থাৎ যা খুশি ঘটতে পারে, আর compiler কোনো প্রতিশ্রুতি দেয় না।

“যা খুশি” কথাটি শুনতে অস্পষ্ট লাগে। তাই একটি সম্ভাব্য ঘটনা ধাপে ধাপে দেখি। মনে রাখবেন, এটি যা ঘটতে পারে, তার একটি উদাহরণ — ভ্যারিয়েবলগুলো মেমরিতে কোন ক্রমে বসবে, তা compiler-এর ইচ্ছা, আর আপনার কম্পিউটারে হুবহু এমন না-ও ঘটতে পারে।

1int bonus = 10;2int marks[5] = {72, 85, 64, 90, 58};34marks[5] = 99;     // সীমার বাইরে!5printf("bonus = %d\n", bonus);

বাস্তবে কেউ সরাসরি marks[5] = 99 লেখে না। ভুলটি আসে লুকিয়ে — for (i = 0; i <= 5; i++), যেখানে <-এর জায়গায় <=. পর্ব ১২-এর off-by-one ভুল অ্যারের সাথে মিললে সেটিই হয়ে যায় মেমরি নষ্ট করার ভুল।

কেন এটি নিরাপত্তার সমস্যা

পাশের ভ্যারিয়েবল নষ্ট হওয়া তো শুধু শুরু। সীমার বাইরে লেখাকে বলে buffer overflow, আর সীমার বাইরে পড়াকে বলে buffer over-read. দুটিই আক্রমণকারীর হাতে বড় অস্ত্র। লেখার বেলায় আক্রমণকারী ইচ্ছা করে লম্বা ইনপুট পাঠিয়ে পাশের গুরুত্বপূর্ণ তথ্য — এমনকি ফাংশন শেষে কোথায় ফিরবে সেই ঠিকানা (পর্ব ১৩-এর return address) — বদলে দিতে পারে। পড়ার বেলায় প্রোগ্রাম ভুল করে পাশের গোপন তথ্য বাইরে পাঠিয়ে দিতে পারে।

কীভাবে ধরবেন

Compiler অনেক সময় স্থির index-এর ভুল (যেমন marks[5]) ধরে warning দেয়, কিন্তু লুপের ভেতরের ভুল সাধারণত পারে না। সবচেয়ে কার্যকর অস্ত্র পর্ব ০৩-এ পরিচিত হওয়া sanitizer:

gcc -Wall -Wextra -g -fsanitize=address marks.c -o marks

এভাবে বানানো প্রোগ্রাম চলার সময় প্রতিটি অ্যারের দুই পাশে “পাহারাদার” জায়গা রাখে। কেউ সেখানে ছুঁলেই প্রোগ্রাম থেমে যায় এবং stack-buffer-overflow লিখে ঠিক কোন লাইনে ঘটেছে দেখিয়ে দেয়। প্রোগ্রাম কিছুটা ধীর হয়, তাই এটি পরীক্ষার সময়ের জন্য, চূড়ান্ত সংস্করণের জন্য নয়।

৫ · লুপ দিয়ে পুরো অ্যারে ঘোরা — চারটি ছাঁচ

অ্যারে আর লুপ যেন একই জোড়ার দুই অংশ। লুপের গণনা-ভ্যারিয়েবল i একে একে 0, 1, 2… হয়, আর a[i] একে একে প্রতিটি ঘর ছুঁয়ে যায়। অ্যারের প্রায় সব কাজ চারটি পরিচিত ছাঁচের কোনো একটি:

চতুর্থ ছাঁচটি সবচেয়ে মজার, আর এতেই off-by-one ভুল সবচেয়ে বেশি হয়। “পরে” চাপুন — দুই প্রান্ত থেকে দুটি index কীভাবে মাঝখানে এসে মেলে, দেখুন:

1int a[5] = {10, 20, 30, 40, 50};2int i = 0, j = 4;          // j = n - 13while (i < j) {4    int tmp = a[i];5    a[i] = a[j];6    a[j] = tmp;7    i++; j--;8}

এবার প্রথম তিনটি ছাঁচ একসাথে। নিচের প্রোগ্রাম ছয়জন ছাত্রের নম্বর থেকে মোট, গড়, সর্বোচ্চ আর গড়ের ওপরে কতজন — চারটি তথ্য বের করে। চালিয়ে দেখুন, তারপর হাতে হিসাব মিলিয়ে নিন:

#include <stdio.h>

int main(void) {
    int marks[] = {72, 85, 64, 90, 58, 77};
    int n = sizeof(marks) / sizeof(marks[0]);
    int sum = 0, best = marks[0], above = 0;

    for (int i = 0; i < n; i++) {
        sum += marks[i];
        if (marks[i] > best) best = marks[i];
    }
    double avg = (double)sum / n;
    for (int i = 0; i < n; i++)
        if (marks[i] > avg) above++;

    printf("students = %d, total = %d\n", n, sum);
    printf("average = %.2f, highest = %d\n", avg, best);
    printf("above average: %d\n", above);
    return 0;
}

৬ · ফাংশনে অ্যারে পাঠানো — ঠিকানা যায়, দৈর্ঘ্য হারায়

পর্ব ১৩-এ শিখেছিলেন, C-তে ফাংশন পায় argument-এর একটি কপি — pass by value. ফাংশনের ভেতরে কপি বদলালে আসল ভ্যারিয়েবল বদলায় না। অ্যারের বেলায় নিয়মটি একটু অন্যভাবে কাজ করে, আর এটি না জানলে দুটি বড় চমক অপেক্ষা করছে।

ধরুন ১০ লাখ ঘরের একটি অ্যারে। প্রতিবার ফাংশন ডাকার সময় পুরো ৪০ লাখ বাইট কপি করা হলে প্রোগ্রাম ধীর হয়ে যেত। তাই C পুরো অ্যারে পাঠায় না — পাঠায় শুধু তার base address. ফাংশন জানে “অ্যারেটি কোথা থেকে শুরু”, কিন্তু জানে না “কতদূর পর্যন্ত”। নিচের প্রোগ্রামটি চালিয়ে দুটি চমকই নিজের চোখে দেখুন — এবারে compiler একটি warning দেবে, সেটিও এই শিক্ষার অংশ:

#include <stdio.h>

void add_grace(int a[], int n) {
    printf("inside add_grace: sizeof(a) = %zu\n", sizeof(a));
    for (int i = 0; i < n; i++)
        a[i] += 5;                       /* grace marks */
}

int main(void) {
    int marks[5] = {72, 85, 64, 90, 58};
    printf("in main: sizeof(marks) = %zu\n", sizeof(marks));
    for (int i = 0; i < 3; i++)
        printf("&marks[%d] = %p\n", i, (void *)&marks[i]);
    add_grace(marks, 5);
    printf("after add_grace: marks[0] = %d\n", marks[0]);
    return 0;
}

৭ · 2D অ্যারে — সারি আর কলামের টেবিল

পরীক্ষার ফলাফলের খাতা মনে করুন। প্রতিটি সারিতে একজন ছাত্র, প্রতিটি কলামে একটি বিষয়। এমন টেবিল রাখতে C-তে আছে 2D array — দুটি index-এর অ্যারে:

int result[3][4] = {          /* ৩ জন ছাত্র × ৪টি বিষয় */
    {78, 65, 82, 90},         /* ছাত্র 0: বাংলা, ইংরেজি, গণিত, বিজ্ঞান */
    {55, 72, 68, 61},         /* ছাত্র 1 */
    {88, 91, 95, 84}          /* ছাত্র 2 */
};
result[2][1]   /* ছাত্র 2-এর ইংরেজি = 91 */

প্রথম index সারি (কোন ছাত্র), দ্বিতীয় index কলাম (কোন বিষয়)। সব ঘর ঘুরতে লাগে পর্ব ১২-এর nested loop — বাইরের লুপ সারি ধরে, ভেতরের লুপ সেই সারির কলাম ধরে। সিনেমা হলের আসনের নকশা, দাবার বোর্ড, ছবির পিক্সেল — সবই এই আকারের। এখানে শুধু মূল ধারণাটি দেখব; ফাংশনে পাঠানো, heap-এ বানানো আর matrix-এর কাজ বিস্তারিত আসবে পর্ব ২১-এ।

কিন্তু একটি প্রশ্ন: মেমরি তো একটি লম্বা সারি মাত্র — ঠিকানা 1000, 1001, 1002… সেখানে “টেবিল” রাখা যায় কীভাবে? উত্তর: রাখা যায় না। C টেবিলটিকে কেটে সারিগুলো একটির পর একটি বসিয়ে দেয়। একে বলে row-major order. ছোট একটি int t[2][3] = {{1, 2, 3}, {4, 5, 6}}; দিয়ে দেখি (base address 2000 ধরে):

৮ · মেমরির বিন্যাস কেন গতি ঠিক করে — cache-এর গল্প

একটি অবাক করা সত্য: আধুনিক CPU এত দ্রুত যে মূল মেমরি (RAM) থেকে একটি মান আনতে যে সময় লাগে, ততক্ষণে CPU কয়েকশো হিসাব সেরে ফেলতে পারত। প্রতিবার RAM-এর জন্য অপেক্ষা করলে CPU-র বেশিরভাগ সময় বসে কাটত। সমাধান হলো cache — CPU-র একেবারে গায়ে লাগানো ছোট কিন্তু খুব দ্রুত মেমরি, যেখানে সম্প্রতি ব্যবহৃত ডেটার কপি রাখা হয়।

CPU ঠিক এই বুদ্ধিটাই খাটায়। RAM থেকে একটি int চাইলে সে শুধু ৪ বাইট আনে না, তার আশেপাশের একটি পুরো টুকরো আনে — আজকের সাধারণ কম্পিউটারে সাধারণত ৬৪ বাইট, যাকে বলে cache line. ৬৪ বাইটে ১৬টি int ধরে। তাই marks[0] আনতে গেলে marks[1] থেকে marks[15] বিনা খরচে চলে আসে। পরের ১৫ বার RAM-এ যেতেই হয় না। “এখন যেটা ছুঁলাম, তার পাশেরটা সম্ভবত পরে ছোঁব” — এই ধারণার নাম spatial locality.

এবার অংশ ৭-এর শেষ প্রশ্নের উত্তর। ধরুন int big[1000][1000] — প্রতি সারি ৪০০০ বাইট।

দুটি কোড একই উত্তর দেয়, একই সংখ্যক যোগ করে। তবু বড় টেবিলে দ্বিতীয়টি কয়েক গুণ ধীর হতে পারে — কত গুণ, তা কম্পিউটার আর টেবিলের মাপের ওপর নির্ভর করে। পার্থক্যটা কোডের যুক্তিতে নয়, মেমরির বিন্যাসে।

৯ · AI-এর যুগে — অ্যারের ভুল যা চোখ এড়িয়ে যায়

AI অ্যারের কোড খুব দ্রুত লেখে, আর বেশিরভাগ সময় ঠিকঠাক চলেও। সমস্যা হলো, অ্যারের ভুল প্রায়ই চোখে পড়ে না — প্রোগ্রাম চলে, সাধারণ ইনপুটে সঠিক উত্তর দেয়, আর ভুলটি প্রকাশ পায় কেবল শেষ ঘরে, খালি তালিকায়, বা অন্য কম্পিউটারে। এই পর্বের প্রতিটি ধারণা আসলে AI-এর কোড যাচাইয়ের একটি অস্ত্র।

AI-এর লেখা অ্যারের কোডে যেসব ভুল প্রায়ই থাকে

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

• প্রতিটি লুপের শর্ত দেখেছি: index 0 থেকে শুরু, < n-এ শেষ — কোথাও <= n নেই
• অ্যারে নেয় এমন প্রতিটি ফাংশন দৈর্ঘ্যও নেয়, আর ভেতরে parameter-এর ওপর sizeof নেই
• শুধু পড়ে এমন ফাংশনে const আছে
• n = 0, n = 1 আর সব-ঋণাত্মক মান দিয়ে চালিয়েছি, হাতে হিসাব মিলিয়েছি
• একবার -fsanitize=address দিয়ে বানিয়ে চালিয়েছি, কোনো রিপোর্ট আসেনি