লিখিত ও মৌখিক (ভাইভা) প্রশ্ন — পূর্ণ নম্বরের উত্তর লেখার কৌশল

Compiler পুরো source code একবারে machine code-এ অনুবাদ করে একটি আলাদা executable ফাইল বানায়; পরে সেই ফাইল যতবার খুশি চালানো যায়। Interpreter প্রোগ্রাম চলার সময় কোড পড়ে পড়ে চালায়, আলাদা ফাইল বানায় না।

ফলাফল: compiled প্রোগ্রাম সাধারণত দ্রুত চলে, আর অনেক ভুল চালানোর আগেই ধরা পড়ে; interpreted ভাষায় লেখা-পরীক্ষা দ্রুত, কিন্তু চালানো তুলনামূলক ধীর। C একটি compiled ভাষা — GCC বা Clang preprocess, compile, assemble ও link করে প্রোগ্রাম তৈরি করে। Python-এর প্রচলিত বাস্তবায়ন interpreter ব্যবহার করে (ভেতরে আগে bytecode বানিয়ে নেয়)।

ঝালিয়ে নিন: পর্ব ০৩ · টুলচেইন

Token হলো প্রোগ্রামের ক্ষুদ্রতম অর্থবহ একক, যা compiler আলাদাভাবে চেনে। C-তে token-এর ধরন: keyword (int, while), identifier (sum), constant (5), string literal ("Dhaka"), আর operator ও punctuator (+, =, ;). অনেক পাঠ্যবইয়ে operator আর special symbol আলাদা ধরে ছয় ধরন বলা হয়; standard এগুলোকে punctuator নামে একসাথে রাখে।

int sum = a + 5; লাইনে token সাতটি: int, sum, =, a, +, 5, ;. Space ও comment token নয় — compiler এগুলো ফেলে দেয়।

ঝালিয়ে নিন: পর্ব ০৪ · প্রথম প্রোগ্রাম

Variable হলো মেমরির একটি নামযুক্ত জায়গা, যার মান প্রোগ্রাম চলার সময় বদলানো যায়; প্রতিটি variable-এর একটি টাইপ থাকে (int age = 20;). Constant এমন মান যা বদলায় না।

C-তে constant পাওয়ার উপায়: (১) literal — সরাসরি লেখা মান, যেমন 3.14, 'A'; (২) const qualifier — const int MAX = 100;, বদলানোর চেষ্টা করলে compiler error দেয়; (৩) #define PI 3.14159 — preprocessor লেখা বদলে দেয়, টাইপ থাকে না; (৪) enum — নামযুক্ত পূর্ণসংখ্যার constant. আধুনিক কোডে const বা enum সাধারণত বেশি নিরাপদ, কারণ টাইপ যাচাই হয়।

ঝালিয়ে নিন: পর্ব ০৬ · ভ্যারিয়েবল ও টাইপ

Storage class ঠিক করে একটি ভ্যারিয়েবল কোথায় দেখা যায় (scope), কতক্ষণ বাঁচে (lifetime), আর শুরুর মান না দিলে কী থাকে।

• auto — ফাংশনের ভেতরের সাধারণ ভ্যারিয়েবলের ডিফল্ট; block শেষ হলেই শেষ; শুরুর মান অনির্ধারিত (garbage).
• register — compiler-কে ইঙ্গিত “দ্রুত রাখো”; এর ঠিকানা (&) নেওয়া যায় না। আধুনিক compiler নিজেই সিদ্ধান্ত নেয়।
• static — ফাংশনের ভেতরে হলে পুরো প্রোগ্রাম জুড়ে বাঁচে এবং ডাকের মাঝে মান মনে রাখে; বাইরে হলে শুধু সেই ফাইলে দেখা যায়। শুরুর মান 0.
• extern — অন্য ফাইলে সংজ্ঞায়িত global ভ্যারিয়েবল বা ফাংশন এখানে ব্যবহারের ঘোষণা।

C11 থেকে _Thread_local যোগ হয়েছে — প্রতিটি thread-এর আলাদা কপি।

ঝালিয়ে নিন: পর্ব ১৪ · স্কোপ ও স্টোরেজ ক্লাস

পয়েন্টার এমন একটি ভ্যারিয়েবল, যা অন্য কোনো ভ্যারিয়েবলের মেমরি ঠিকানা রাখে। &x দেয় x-এর ঠিকানা (address-of), আর *p দেয় p যে ঠিকানায় আছে সেখানকার মান (dereference).

উদাহরণ: int x = 10; int *p = &x; *p = 20; — এরপর x-এর মান 20, কারণ p আর x একই ঘরের দিকে নির্দেশ করে। পয়েন্টারের টাইপ ঠিক করে *p কত বাইট পড়বে আর p + 1 কত বাইট এগোবে। ব্যবহার: ফাংশন থেকে মূল মান বদলানো, array ও string, dynamic memory, linked list. পূর্ণ নম্বরের বিস্তারিত উত্তর অংশ ২-এর ডায়াগ্রামে দেখুন।

ঝালিয়ে নিন: পর্ব ১৭ · পয়েন্টার ১

NULL pointer এমন একটি পয়েন্টার, যা নিশ্চিতভাবে কোনো বৈধ বস্তুকে নির্দেশ করে না। NULL একটি macro (stddef.h, stdio.h, stdlib.h-এ সংজ্ঞায়িত); C23 থেকে nullptr-ও আছে।

ব্যবহার: (১) পয়েন্টার ঘোষণার সময় শুরুর মান — int *p = NULL;; (২) ব্যর্থতা জানানো — malloc ও fopen ব্যর্থ হলে NULL ফেরত দেয়, তাই সবসময় if (p == NULL) যাচাই করতে হয়; (৩) linked list-এর শেষ চিহ্ন। NULL pointer-কে dereference করা undefined behavior; Linux-এ সাধারণত segmentation fault হয়ে প্রোগ্রাম বন্ধ হয়।

ঝালিয়ে নিন: পর্ব ১৭ · পয়েন্টার ১

Dangling pointer এমন পয়েন্টার, যা এমন মেমরিকে নির্দেশ করছে যার মেয়াদ আর নেই। এটি ব্যবহার করা undefined behavior.

তৈরি হওয়ার তিন পথ: (১) free(p)-এর পরও p ব্যবহার (use-after-free); (২) ফাংশন থেকে local ভ্যারিয়েবলের ঠিকানা ফেরত দেওয়া — ফাংশন শেষ হলেই সেই stack জায়গা বাতিল; (৩) block-এর ভেতরের ভ্যারিয়েবলের ঠিকানা block-এর বাইরে ব্যবহার।

এড়ানোর উপায়: free(p); p = NULL;, local-এর ঠিকানা ফেরত না দেওয়া (দরকার হলে malloc বা caller-এর দেওয়া buffer), আর AddressSanitizer দিয়ে পরীক্ষা। তুলনা: wild pointer হলো যাকে কখনো শুরুর মানই দেওয়া হয়নি।

ঝালিয়ে নিন: পর্ব ২০ · ডায়নামিক মেমরি

Recursion হলো একটি ফাংশনের নিজেকেই ডাকা, প্রতিবার সমস্যার ছোট সংস্করণ দিয়ে। এর দুটি অংশ: base case — যেখানে আর নিজেকে না ডেকে সরাসরি উত্তর দেয়; আর recursive case — যেখানে ছোট সমস্যার জন্য নিজেকে ডাকে। যেমন fact(n) = n * fact(n - 1), base case fact(0) = 1.

প্রতিটি ডাকে call stack-এ একটি নতুন frame জমে। Base case না থাকলে বা কখনো না পৌঁছালে ডাক থামে না, stack-এর জায়গা ফুরিয়ে যায় — stack overflow, সাধারণত crash. Recursion কোড ছোট ও পরিষ্কার করে (tree, divide and conquer), কিন্তু loop-এর চেয়ে বাড়তি মেমরি ও সময় খরচ হতে পারে।

ঝালিয়ে নিন: পর্ব ১৫ · রিকার্শন

Array হলো একই টাইপের মানের পাশাপাশি সাজানো ব্লক; পয়েন্টার হলো একটি ঠিকানা রাখার ভ্যারিয়েবল। দুটি এক নয়, কিন্তু ঘনিষ্ঠ: বেশিরভাগ expression-এ array-র নাম তার প্রথম element-এর পয়েন্টারে রূপ নেয় (array decay). তাই a[i] আসলে *(a + i), আর ফাংশনে array পাঠালে পয়েন্টারই যায়।

পার্থক্যগুলো: sizeof a পুরো array-র মাপ দেয়, পয়েন্টারের নয়; a = b; লেখা যায় না, কিন্তু পয়েন্টারে নতুন ঠিকানা বসানো যায়; &a-র টাইপ পুরো array-র পয়েন্টার। Decay হয় না তিন জায়গায়: sizeof, &, আর string literal দিয়ে char array-র শুরুর মান দেওয়ার সময়।

ঝালিয়ে নিন: পর্ব ১৮ · পয়েন্টার ২

C-তে আলাদা string টাইপ নেই। String হলো char-এর array, যার শেষে একটি null terminator '\0' থাকে — এটি দেখেই strlen, printf("%s") বোঝে string কোথায় শেষ। "Dhaka"-তে অক্ষর ৫টি, তাই লাগে ৬ বাইট: char city[6] = "Dhaka";.

সতর্কতা: (১) '\0'-এর জায়গা না রাখলে string-এর শেষ খুঁজে না পেয়ে ফাংশন মেমরির বাইরে পড়ে; (২) char *s = "Dhaka"; একটি string literal-কে নির্দেশ করে, যা বদলানো undefined behavior; (৩) তুলনা == দিয়ে নয়, strcmp দিয়ে — == শুধু ঠিকানা তুলনা করে।

ঝালিয়ে নিন: পর্ব ১৯ · স্ট্রিং

Structure হলো বিভিন্ন টাইপের কয়েকটি মানকে এক নামে বাঁধা নিজের তৈরি টাইপ — যেমন একজন ছাত্রের roll, নাম আর নম্বর। প্রতিটি member-এর আলাদা জায়গা থাকে, তাই সবগুলো একসাথে রাখা যায়।

Union-এ সব member একই মেমরি ভাগ করে; মাপ হয় সবচেয়ে বড় member-এর সমান (alignment-এর জন্য একটু বাড়তে পারে)। এক সময়ে শুধু একটি member-এর মান অর্থবহ। ব্যবহার: যেখানে একটি মান কয়েক রকমের যেকোনো একটি হতে পারে — যেমন একটি নেটওয়ার্ক বার্তায় হয় সংখ্যা, নয় লেখা; সাথে একটি tag রাখা হয় কোনটি চলছে বোঝাতে (tagged union). Member পড়া হয় . দিয়ে, পয়েন্টার থাকলে -> দিয়ে।

ঝালিয়ে নিন: পর্ব ২২ · struct ও union

File mode জানায় ফাইল কী উদ্দেশ্যে খোলা হচ্ছে:

• "r" — শুধু পড়া; ফাইল না থাকলে fopen NULL দেয়।
• "w" — লেখা; ফাইল না থাকলে তৈরি করে, থাকলে আগের সব লেখা মুছে ফেলে।
• "a" — শেষে যোগ (append); আগের লেখা থাকে, নতুন লেখা সবসময় শেষে বসে।
• "r+" — পড়া ও লেখা, ফাইল থাকতেই হবে; "w+" — পড়া ও লেখা, আগের লেখা মুছে; "a+" — পড়া ও শেষে যোগ।

শেষে b যোগ করলে ("rb", "wb") binary mode — কোনো অনুবাদ ছাড়া হুবহু বাইট। C11 থেকে "wx": ফাইল আগে থেকে থাকলে খোলা ব্যর্থ হয়। সবসময় NULL যাচাই আর কাজ শেষে fclose.

ঝালিয়ে নিন: পর্ব ২৪ · ফাইল I/O

Macro হলো #define দিয়ে দেওয়া একটি নাম, যাকে preprocessor compile-এর আগে লেখা হিসেবে বদলে দেয়। দুই রকম: object-like (#define MAX 100) আর function-like (#define SQUARE(x) ...). Macro-তে টাইপ যাচাই হয় না, ফাংশন ডাকার খরচও নেই।

SQUARE(2 + 3) বদলে হয় 2 + 3*2 + 3 = 11, 25 নয় — কারণ শুধু লেখা বসানো হয়, অগ্রাধিকার মানা হয় না। সমাধান: #define SQUARE(x) ((x) * (x)). তবু SQUARE(i++) লিখলে i দুবার বাড়ানো হয় — এটি double evaluation, আর এক expression-এ একই ভ্যারিয়েবল দুবার বদলানো undefined behavior. তাই এমন ক্ষেত্রে static inline ফাংশন ভালো।

ঝালিয়ে নিন: পর্ব ২৭ · প্রিপ্রসেসর ও ম্যাক্রো

Header file (.h) হলো একটি ফাইল, যাতে ঘোষণা থাকে — কী কী ফাংশন, টাইপ ও macro পাওয়া যাবে। #include করলে preprocessor ফাইলটির লেখা সেখানে বসিয়ে দেয়। যেমন stdio.h-তে printf-এর prototype আছে, আসল কোড আছে C library-তে।

রাখুন: function prototype, struct/typedef, macro, extern ঘোষণা। রাখবেন না: ফাংশনের পূর্ণ সংজ্ঞা বা global ভ্যারিয়েবলের সংজ্ঞা — একাধিক .c ফাইল include করলে linker “multiple definition” error দেবে (ব্যতিক্রম: static inline ফাংশন)। একই header দুবার ঢোকা ঠেকাতে include guard (#ifndef … #define … #endif) ব্যবহার করুন।

ঝালিয়ে নিন: পর্ব ২৯ · মডুলার প্রোগ্রাম

Dynamic memory allocation মানে প্রোগ্রাম চলার সময় দরকারমতো মেমরি নেওয়া ও ফেরত দেওয়া। এই মেমরি আসে heap থেকে, আর যতক্ষণ না আপনি ফেরত দেন ততক্ষণ থাকে — ফাংশন শেষ হলেও।

• malloc(size) — size বাইট দেয়, ভেতরের মান অনির্ধারিত।
• calloc(n, size) — n টি element-এর জায়গা দেয়, সব বাইট শূন্য করে।
• realloc(p, size) — আগের ব্লক বড় বা ছোট করে; দরকারে নতুন জায়গায় সরিয়ে পুরোনো ডেটা কপি করে।
• free(p) — মেমরি ফেরত দেয়।

নিয়ম: প্রতিটি ফেরত মান NULL কি না যাচাই, প্রতিটি allocation ঠিক একবার free, আর p = realloc(p, …) না লিখে আগে অস্থায়ী পয়েন্টারে নিন — ব্যর্থ হলে আসল ঠিকানা হারাবে না।

ঝালিয়ে নিন: পর্ব ২০ · ডায়নামিক মেমরি

Memory leak হলো heap থেকে নেওয়া মেমরি কাজ শেষে free না করা, বিশেষত যখন সেই মেমরির ঠিকানাও হারিয়ে যায় — তখন আর কখনোই ফেরত দেওয়া সম্ভব নয়। যেমন লুপের ভেতরে বারবার malloc, কিন্তু free নেই; বা p = malloc(...) দুবার লেখা, প্রথম ঠিকানা হারিয়ে গেল।

ছোট প্রোগ্রাম শেষ হলে OS সব মেমরি ফেরত নেয়, তাই চোখে পড়ে না। কিন্তু দিনের পর দিন চলা সার্ভার বা এমবেডেড ডিভাইসে মেমরি ধীরে ধীরে ফুরিয়ে যায়, শেষে প্রোগ্রাম ধীর হয় বা বন্ধ হয়। ধরার উপায়: Valgrind (valgrind --leak-check=full ./prog), আর GCC/Clang-এ -fsanitize=address — Linux-এ এর সাথে leak detection-ও চালু থাকে।

ঝালিয়ে নিন: পর্ব ২০ · ডায়নামিক মেমরি, পর্ব ৩১ · ডিবাগিং

Undefined behavior (UB) হলো এমন কাজ, যার ফল সম্পর্কে C standard কোনো শর্তই দেয় না — প্রোগ্রাম ঠিক চলতে পারে, ভুল ফল দিতে পারে, crash করতে পারে, বা optimization চালু করলে আচরণ বদলে যেতে পারে। Compiler ধরে নেয় কোডে UB নেই, এবং সেই অনুমানে কোড বদলায়।

উদাহরণ: signed int overflow (INT_MAX + 1), array-র সীমার বাইরে পড়া-লেখা, NULL বা dangling pointer dereference, শুরুর মান ছাড়া local ভ্যারিয়েবলের মান ব্যবহার, আর i = i++ + 1;-এর মতো একই ভ্যারিয়েবল ক্রমহীনভাবে দুবার বদলানো।

Implementation-defined আচরণ প্রতিটি compiler নিজের মতো ঠিক করে এবং নথিতে লিখে রাখে — যেমন sizeof(int), বা char signed নাকি unsigned. Unspecified মানে কয়েকটি সম্ভাবনার যেকোনোটি, নথিভুক্ত করার দরকার নেই — যেমন ফাংশনের argument-গুলোর মূল্যায়নের ক্রম।

ঝালিয়ে নিন: পর্ব ৪৬ · Undefined Behavior ও নিরাপদ কোডিং

Linked list হলো node-এর একটি শিকল; প্রতিটি node-এ থাকে ডেটা আর পরের node-এর ঠিকানা। প্রথম node-এর ঠিকানা রাখে head, শেষ node-এর next হয় NULL.

struct node {
    int data;
    struct node *next;   /* পরের node-এর ঠিকানা */
};

সুবিধা: আকার চলার সময় বাড়ে-কমে; জানা node-এর পরে যোগ বা বাদ O(1), কিছু সরাতে হয় না। অসুবিধা: i-তম element পেতে শুরু থেকে হাঁটতে হয় — O(n); প্রতি node-এ পয়েন্টারের বাড়তি মেমরি; node-গুলো মেমরিতে ছড়ানো, তাই cache-এ ধীর। ধরন: singly, doubly, circular.

ঝালিয়ে নিন: পর্ব ৩৩ · লিংকড লিস্ট

Stack চলে LIFO নিয়মে — যে শেষে ঢোকে, সে আগে বের হয়, ঠিক থালার স্তূপের মতো। মূল কাজ push (ওপরে রাখা) আর pop (ওপর থেকে নেওয়া)। ব্যবহার: ফাংশন কলের call stack, undo, ব্র্যাকেট মেলানো, expression হিসাব, DFS.

Queue চলে FIFO নিয়মে — যে আগে আসে, সে আগে যায়, ঠিক ব্যাংকের লাইনের মতো। মূল কাজ enqueue (পেছনে যোগ) আর dequeue (সামনে থেকে নেওয়া)। ব্যবহার: প্রিন্টারের কাজের লাইন, BFS, CPU-র round-robin scheduling, নেটওয়ার্কের buffer. দুটিই array বা linked list দিয়ে বানানো যায়; array-তে queue-র জন্য circular buffer সুবিধাজনক। সব মূল কাজ O(1).

ঝালিয়ে নিন: পর্ব ৩৪ · স্ট্যাক ও কিউ

Time complexity মাপে ইনপুটের আকার n বাড়লে একটি অ্যালগরিদমের ধাপের সংখ্যা কীভাবে বাড়ে — সেকেন্ডে নয়, বৃদ্ধির হারে, যাতে মেশিনের গতির ওপর নির্ভর না করে। Big-O দেয় সেই বৃদ্ধির ঊর্ধ্বসীমা, ছোট পদ ও ধ্রুবক বাদ দিয়ে: 3n² + 5n + 2 হলো O(n²).

উদাহরণ: array-র index দিয়ে পড়া O(1); binary search O(log n); linear search O(n); merge sort O(n log n); bubble sort O(n²). n = 10⁶ হলে O(n log n) মোটামুটি দুই কোটি ধাপ, কিন্তু O(n²) এক লক্ষ কোটি ধাপ — পার্থক্য সেকেন্ড বনাম ঘণ্টা। উত্তরে best, average ও worst case আলাদা করে বলুন, যেমন quicksort-এর average O(n log n) কিন্তু worst O(n²).

ঝালিয়ে নিন: পর্ব ৩৯ · কমপ্লেক্সিটি

int — প্রোগ্রামের exit status, যা OS বা shell পায়। 0 মানে সফল, অন্য মান মানে কোনো সমস্যা। C99 থেকে main-এর শেষে return না লিখলে 0 ধরে নেওয়া হয়। পর্ব ০৪

না, এটি একটি operator. সাধারণত compile-এর সময়ই মান ঠিক হয় (ব্যতিক্রম VLA), ফল size_t টাইপের; ছাপতে %zu. ভেরিয়েবলের ক্ষেত্রে বন্ধনী ছাড়াও লেখা যায়: sizeof x. পর্ব ০৬

Standard শুধু বলে int অন্তত 16 bit; আজকের সাধারণ 32/64-bit Linux ও Windows-এ 4 বাইট। char signed না unsigned — implementation-defined: x86 Linux-এর GCC-তে signed, ARM Linux-এ সাধারণত unsigned. তাই ভাইভায় বলুন “প্ল্যাটফর্মের ওপর নির্ভর করে”। পর্ব ০৫

5 / 2 = 2 — দুটোই int, তাই integer division, দশমিক অংশ কেটে যায়। 5 / 2.0 = 2.5 — একটি double থাকায় অন্যটিও double-এ রূপান্তরিত হয় (usual arithmetic conversions). পর্ব ০৮

n-এর সবচেয়ে ডানের bit. ফল 1 হলে n বিজোড়, 0 হলে জোড় (অঋণাত্মক সংখ্যার জন্য নিশ্চিন্তে; আধুনিক two's complement সিস্টেমে ঋণাত্মকেও ঠিক কাজ করে)। পর্ব ০৯

Fall-through — মিলে যাওয়া case-এর পরের সব case-এর কোডও চলতে থাকে, যতক্ষণ না break বা switch-এর শেষ আসে। কখনো ইচ্ছে করে করা হয়; তখন মন্তব্যে লিখে দেওয়া ভালো। পর্ব ১১

Global ও static ভ্যারিয়েবল আপনাআপনি 0 হয়। Local (automatic) ভ্যারিয়েবলের মান অনির্ধারিত — garbage; শুরুর মান না দিয়ে পড়লে ফল অনির্ভরযোগ্য। পর্ব ১৪

সমস্যার ওপর নির্ভর করে। Tree, divide and conquer, backtracking-এ recursion স্বাভাবিক ও পরিষ্কার; সরল পুনরাবৃত্তিতে loop দ্রুত ও stack-নিরাপদ। খুব গভীর recursion-এ stack overflow-এর ঝুঁকি। পর্ব ১৫

Generic pointer — যেকোনো object-এর ঠিকানা রাখতে পারে, কিন্তু টাইপ জানে না বলে সরাসরি dereference বা pointer arithmetic করা যায় না (standard C-তে)। malloc এটিই ফেরত দেয়; C-তে int *p = malloc(...) লিখতে cast লাগে না। পর্ব ১৭

sizeof(int) বাইট — সাধারণত 4. Pointer arithmetic সবসময় নির্দেশিত টাইপের মাপের এককে চলে; double * হলে 8 বাইট, char * হলে 1. পর্ব ১৮

Undefined behavior — string literal বদলানো নিষেধ। Linux-এ literal সাধারণত read-only মেমরিতে থাকে, তাই প্রায়ই segmentation fault. বদলাতে চাইলে char s[] = "hi"; — এটি একটি নিজস্ব array কপি। পর্ব ১৯

যাতে ভুলে আবার ব্যবহার (use-after-free) বা দ্বিতীয়বার free (double free) না হয় — NULL হলে ভুলটা সাথে সাথে ধরা পড়ে। হ্যাঁ, free(NULL) standard অনুযায়ী কিছুই করে না। পর্ব ২০

C-তে row-major — প্রথম সারির সব উপাদান, তারপর দ্বিতীয় সারি, এভাবে এক টানা। int a[R][C]-এ a[i][j]-এর অবস্থান শুরু থেকে (i * C + j) উপাদান দূরে। তাই সারি ধরে লুপ চালানো cache-এ দ্রুত। পর্ব ২১

typedef compiler-এর কাছে আসল টাইপের নাম; #define শুধু লেখা বদল। #define PTR int * দিয়ে PTR a, b; হয় int *a, b; — b সাধারণ int! typedef int *PTR; হলে দুটিই পয়েন্টার। পর্ব ২২

int main(int argc, char *argv[]) — argc হলো কমান্ড-লাইনের শব্দের সংখ্যা, argv সেগুলোর string-এর array. argv[0] সাধারণত প্রোগ্রামের নাম, আর argv[argc] সবসময় NULL. পর্ব ২৫

qsort-কে তুলনার নিয়ম জানানো — comparator ফাংশনের ঠিকানা পাঠানো হয়। এছাড়া callback, মেনুর জন্য dispatch table, আর event handler. পর্ব ২৮

অনেক library ফাংশন ব্যর্থ হলে errno-তে কারণের কোড রাখে; perror("msg") সেটি পড়ে মানুষের বোধগম্য বার্তা ছাপে, যেমন input.txt: No such file or directory. errno দেখতে হয় ব্যর্থতা নিশ্চিত হওয়ার পরই। পর্ব ৩০

-g দিয়ে compile করে gdb-তে চালান; crash-এর পর bt (backtrace) দেখায় কোন ফাংশনের কোন লাইনে থেমেছে। সাথে -fsanitize=address দিয়ে চালালে ভুল পড়া-লেখার সঠিক জায়গা আর কারণ জানা যায়। পর্ব ৩১

দুটিই মেমরির ভুল ধরে। AddressSanitizer compile-এর সময় কোডে পাহারা বসায় (-fsanitize=address), তাই নতুন করে build লাগে, কিন্তু তুলনামূলক দ্রুত (মোটামুটি ২ গুণের মতো ধীর)। Valgrind আগে থেকে তৈরি প্রোগ্রামকে নিজের ভেতরে চালায় — build বদলাতে হয় না, কিন্তু অনেক গুণ ধীর। পর্ব ৩১

Unit test হলো একটি ছোট অংশ — সাধারণত একটি ফাংশন — জানা ইনপুটে প্রত্যাশিত আউটপুট দেয় কি না স্বয়ংক্রিয়ভাবে যাচাই। সহজতম রূপ assert(gcd(12, 18) == 6);; edge case (0, ঋণাত্মক, খালি) অবশ্যই রাখুন। বড় প্রজেক্টে Unity বা CMocka-র মতো framework. পর্ব ৩২

ভারসাম্যপূর্ণ হলে O(log n). কিন্তু সাজানো ক্রমে ঢোকালে tree একটি লম্বা শিকল হয়ে যায় — worst case O(n). AVL বা red-black tree-র মতো self-balancing tree উচ্চতা O(log n)-এ রাখে। পর্ব ৩৫

Binary heap দিয়ে, যা একটি array-তে রাখা যায়: index i-এর সন্তান 2i+1 ও 2i+2. সবচেয়ে বড় (বা ছোট) দেখা O(1), ঢোকানো ও বের করা O(log n). পর্ব ৩৬

গড়ে O(1), কিন্তু অনেক collision হলে worst case O(n). ভালো hash function আর load factor বাড়লে rehash করা — এই দুটিই গড় দ্রুত রাখে। পর্ব ৩৭

BFS queue দিয়ে স্তর ধরে এগোয় — unweighted graph-এ সবচেয়ে কম ধাপের পথ দেয়। DFS stack বা recursion দিয়ে এক পথে যতদূর যাওয়া যায় গিয়ে ফেরে — cycle খোঁজা, topological sort-এ কাজে লাগে। দুটিই O(V + E). পর্ব ৩৮

Pivot বারবার সবচেয়ে ছোট বা বড় উপাদান হলে — যেমন সাজানো array-তে সবসময় প্রথম উপাদানকে pivot নিলে — O(n²). Stable sort সমান মানের উপাদানের আগের আপেক্ষিক ক্রম রাখে; merge sort stable, সাধারণ quicksort নয়। পর্ব ৪০

যখন সমস্যায় একই ছোট সমস্যা বারবার আসে (overlapping subproblems) আর ছোট সমস্যার সেরা উত্তর থেকে বড়টির সেরা উত্তর বানানো যায় (optimal substructure). একবার হিসাব করে মনে রাখা হয় — memoization বা tabulation. পর্ব ৪২

volatile compiler-কে বলে মানটি প্রোগ্রামের বাইরে থেকে বদলাতে পারে — hardware register, interrupt handler — তাই প্রতিবার মেমরি থেকে নতুন করে পড়তে হবে, optimize করে বাদ দেওয়া যাবে না। Thread synchronization-এর জন্য যথেষ্ট নয়; সেখানে mutex বা _Atomic লাগে। পর্ব ৪৫, পর্ব ৫১

C99: // মন্তব্য, for (int i = 0; …), stdint.h, stdbool.h. C11: _Generic, _Static_assert, threads.h (ঐচ্ছিক)। C23: bool/true/false keyword, nullptr, typeof, binary literal 0b1010. পর্ব ৪৭

একবার ডাকলে দুবার ফেরে: child process-এ 0, parent-এ child-এর PID, আর ব্যর্থ হলে parent-এ -1 (কোনো child তৈরি হয় না)। এই মান দেখেই কোড ঠিক করে সে child না parent. পর্ব ৪৮

দুটি thread একই মেমরিতে একসাথে কাজ করছে, অন্তত একটি লিখছে, আর কোনো synchronization নেই — C-তে এটি undefined behavior. ঠেকাতে mutex বা atomic operation; ধরতে -fsanitize=thread (ThreadSanitizer). পর্ব ৪৯

TCP connection বানিয়ে নির্ভরযোগ্য, ক্রম ঠিক রাখা byte stream দেয় (ওয়েব, ইমেইল); UDP connection ছাড়া আলাদা আলাদা বার্তা পাঠায়, পৌঁছানোর নিশ্চয়তা নেই কিন্তু দ্রুত (ভিডিও কল, গেম, DNS). পর্ব ৫০

RAM খুব সীমিত, দীর্ঘদিন চললে fragmentation-এ মেমরি টুকরো হয়ে যায়, আর allocation-এ কত সময় লাগবে আগে থেকে বলা যায় না — real-time কাজে যা বিপজ্জনক। তাই static বা আগে থেকে ঠিক করা buffer ব্যবহার হয়; MISRA C-এর মতো নিরাপত্তা-নির্দেশিকাও dynamic memory সীমিত করে। পর্ব ৫১