স্ট্যান্ডার্ড লাইব্রেরি — C-এর সাথে আসা তৈরি হাতিয়ারের বাক্স

১ · তৈরি হাতিয়ারের বাক্স — standard library আসলে কী

একজন রাজমিস্ত্রির কথা ভাবুন। তিনি প্রতিদিন সকালে নিজে হাতুড়ি, কর্নি আর ওলন বানিয়ে কাজ শুরু করেন না। তাঁর ব্যাগে তৈরি যন্ত্রপাতি থাকে — বহু বছর ধরে হাজারো মিস্ত্রির হাতে পরীক্ষিত। তাঁর আসল দক্ষতা হলো কোন কাজে কোন যন্ত্র লাগবে, সেটা জানা।

C প্রোগ্রামারের ব্যাগটির নাম standard library. প্রথম পর্ব থেকেই আপনি এটি ব্যবহার করছেন — printf, scanf, strlen, malloc, fopen — এর কোনোটিই C ভাষার অংশ নয়! এগুলো সাধারণ ফাংশন, যা কেউ আগে থেকে লিখে compiler-এর সাথে দিয়ে রেখেছেন। এই পর্বে আমরা পুরো ব্যাগটি খুলে দেখব — কী কী আছে, আর কোন যন্ত্রের ধার কোথায় হাত কাটতে পারে।

“স্ট্যান্ডার্ড” মানে কী?

C ভাষার একটি আনুষ্ঠানিক নিয়ম-বই আছে (C standard), যা ISO-র একটি কমিটি দেখাশোনা করে। এই বইয়ের একটা বড় অংশজুড়ে লেখা — কোন কোন header থাকবে, প্রতিটিতে কোন ফাংশন, আর প্রতিটি ফাংশন ঠিক কী আচরণ করবে। অর্থাৎ স্ট্যান্ডার্ড বলে দেয় কী থাকবে; কীভাবে বানানো হবে, সেটা যে বানায় তার ব্যাপার।

এই “বানানো” রূপটিকে বলে libc — C library-র একটি বাস্তব implementation. একাধিক দল আলাদা আলাদা libc বানিয়েছে:

সবগুলোই একই স্ট্যান্ডার্ড মেনে চলে, তাই strlen("Dhaka") সবখানে 5 দেয়। কিন্তু স্ট্যান্ডার্ড যেখানে কিছু খোলা রেখেছে (যেমন rand()-এর সর্বোচ্চ মান কত), সেখানে ফল আলাদা হতে পারে। এই পর্বে সেরকম কয়েকটি জায়গা দেখবেন।

Header আর library ফাইল — দুটো আলাদা জিনিস

পর্ব ০৩-এ toolchain-এর চার ধাপ দেখেছিলেন। সেখান থেকেই এই পার্থক্যটা পরিষ্কার হয়:

এর সবচেয়ে পরিচিত উদাহরণ math library. Linux-এ glibc-র অঙ্কের ফাংশনগুলো ঐতিহাসিক কারণে আলাদা একটি ফাইলে (libm) থাকে। তাই sqrt-এর মতো ফাংশন ব্যবহার করলে কমান্ডের শেষে -lm জুড়তে হয় — “l” মানে library, “m” মানে math:

gcc -Wall -Wextra area.c -o area -lm

এই পর্বের পাশের অনলাইন compiler-এ এটা আমরা নিজেরাই পরীক্ষা করেছি — একটি ভ্যারিয়েবলের sqrt নিতে গেলে -lm ছাড়া linker ঠিক এই error দেয়:

/usr/bin/ld: prog.c:(.text+0x4a): undefined reference to `sqrt'
collect2: error: ld returned 1 exit status

২ · হেডারের মানচিত্র — কোন সমস্যায় কোন বাক্স

সব ফাংশন মুখস্থ রাখার দরকার নেই, পেশাদাররাও রাখেন না। দরকার একটি মানচিত্র — কোন ধরনের কাজের জন্য কোন header খুলতে হবে। নিচের তালিকাটি সেই মানচিত্র। শেষ কলামে লেখা, এই কোর্সের কোন পর্বে সেটি বিস্তারিত আছে।

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

/* stdlib.h */
char *end;
errno = 0;
long taka = strtol(text, &end, 10);
/* end দেখে বুঝুন পুরোটা সংখ্যা ছিল কি না */

/* ctype.h */
for (size_t i = 0; s[i] != '\0'; i++)
    if (!isdigit((unsigned char)s[i]))
        return 0;   /* অঙ্ক নয় এমন কিছু পাওয়া গেল */
return 1;

/* stdlib.h */
int cmp(const void *a, const void *b) {
    int x = *(const int *)a, y = *(const int *)b;
    return (x > y) - (x < y);   /* x - y নয়! */
}
qsort(marks, n, sizeof marks[0], cmp);

/* time.h */
time_t now = time(NULL);
struct tm *t = localtime(&now);
strftime(buf, sizeof buf, "%d %b %Y", t);

/* stdint.h */
uint16_t reading;   /* সব যন্ত্রে ঠিক ১৬ বিট */
/* int হলে কোথাও ১৬, কোথাও ৩২ বিট হতে পারত */

৩ · ctype.h — অক্ষর চেনা আর signed char-এর ফাঁদ

ctype.h-এর ফাংশনগুলো একটি অক্ষর নিয়ে প্রশ্নের উত্তর দেয় — “এটা কি অঙ্ক?”, “এটা কি space?” — অথবা অক্ষরটি বদলে দেয়। এগুলো ছোট, কিন্তু প্রায় প্রতিটি ইনপুট-যাচাইয়ের কোডে লাগে।

খেয়াল করুন, “সত্য” মানে এখানে শূন্য নয় এমন কোনো মান — ঠিক 1 নাও হতে পারে। তাই if (isdigit(c) == 1) লিখবেন না, লিখুন if (isdigit(c)).

সবচেয়ে বিখ্যাত ফাঁদ: ঋণাত্মক char

এই ফাংশনগুলোর argument-এর টাইপ int, আর স্ট্যান্ডার্ডের নিয়ম কড়া: মানটি হতে হবে হয় EOF, নয়তো unsigned char-এ ধরে এমন একটি মান (সাধারণত 0 থেকে 255). এর বাইরে কিছু দিলে ফল undefined behavior.

সমস্যা হলো, x86 কম্পিউটারে char সাধারণত signed — অর্থাৎ 128-এর বেশি মানের বাইট char-এ রাখলে ঋণাত্মক হয়ে যায়। আর বাংলা লেখার প্রতিটি বাইটই 128-এর বেশি! পর্ব ১৯-এ দেখেছেন, UTF-8-এ “অ” তিনটি বাইটে লেখা হয়: E0 A6 85. এবার ধাপে ধাপে দেখুন কী ঘটে:

1const char *s = "অ";   /* bytes: E0 A6 85 */2char c = s[0];         /* byte 0xE0 */3int r1 = toupper(c);4int r2 = toupper((unsigned char)c);

৪ · লেখা থেকে সংখ্যা — atoi কেন নয়, strtol কেন

ধরুন একটি মোবাইল রিচার্জ অ্যাপ বানাচ্ছেন। ইউজার টাকার অঙ্ক লেখেন একটি ঘরে। প্রোগ্রাম পায় একটি স্ট্রিং — "50", বা ভুল করে "5O" (শূন্যের বদলে ইংরেজি O), বা কিছুই না। এই লেখা থেকে নিরাপদে সংখ্যা বানানোই এই অংশের বিষয়। পর্ব ২৫-এ argv-র সংখ্যার জন্য strtol-এর পাহারা প্রথম দেখেছেন; এখানে পুরো ছবিটা দেখব — atoi-র সাথে তুলনা আর একই পরিবারের অন্য ফাংশন।

অনেক বই আর অনেক AI প্রথমেই দেখায় atoi — “ASCII to integer”. দেখতে সহজ, কিন্তু এর একটি বড় দুর্বলতা আছে: ভুল হলে জানানোর কোনো উপায় তার নেই।

strtol-এর তিনটি argument: স্ট্রিং, একটি char *-এর ঠিকানা (যেখানে সে জানায় কোথায় পড়া থামল), আর ভিত্তি (10 মানে দশমিক, 16 মানে hexadecimal). দশমিক সংখ্যার জন্য একই পরিবারের strtod, আর unsigned long-এর জন্য strtoul. নিচের প্রোগ্রামে পাঁচটি ইনপুট একে একে যাচাই করা হচ্ছে — ctype.h-এর isspace দিয়ে শেষের space-ও মাফ করা হয়েছে:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>

int main(void) {
    const char *in[] = {"42", "  -17 ", "12abc", "abc", "99999999999999999999"};
    for (int i = 0; i < 5; i++) {
        const char *s = in[i];
        char *end;
        errno = 0;
        long v = strtol(s, &end, 10);
        while (isspace((unsigned char)*end)) end++;   /* trailing spaces OK */
        printf("%-24s -> ", s);
        if (end == s)             printf("not a number\n");
        else if (errno == ERANGE) printf("too big for long\n");
        else if (*end != '\0')    printf("junk after number: \"%s\"\n", end);
        else                      printf("OK, value = %ld\n", v);
    }
    return 0;
}

stdlib.h-এর আরও কিছু প্রতিদিনের যন্ত্র

৫ · rand() — এলোমেলো, কিন্তু কতটা?

লুডো খেলার একটি অ্যাপ বানাতে গেলে ছক্কা লাগবে। প্রায় সব টিউটোরিয়াল এভাবে লেখে:

srand(time(NULL));          /* একবার, প্রোগ্রামের শুরুতে */
int face = rand() % 6 + 1;  /* 1 থেকে 6 */

খেলার জন্য এটি মোটামুটি চলে। কিন্তু ভেতরে তিনটি বিষয় বোঝা দরকার।

প্রথমত, rand() আসলে এলোমেলো নয়। এটি একটি PRNG — একটি সূত্র, যা আগের মান থেকে পরের মান হিসাব করে। শুরুর মানটির নাম seed. একই seed দিলে প্রতিবার হুবহু একই ধারা আসে। srand(time(NULL)) বর্তমান সময়কে seed বানায়, তাই প্রতিবার আলাদা ধারা পাওয়া যায়। কিন্তু srand প্রতিবার rand()-এর আগে ডাকলে বিপদ — একই সেকেন্ডে সব ডাকেই একই seed, অর্থাৎ একই “এলোমেলো” সংখ্যা! নিয়ম: seed একবারই, প্রোগ্রামের শুরুতে।

দ্বিতীয়ত, % 6 সব মুখকে সমান সুযোগ দেয় না। rand() দেয় 0 থেকে RAND_MAX পর্যন্ত। স্ট্যান্ডার্ড শুধু বলে RAND_MAX অন্তত 32767; glibc-তে এটি 2147483647, MSVC-তে 32767. বোঝার সুবিধার জন্য একটি খেলনা যন্ত্র ধরি যেখানে RAND_MAX = 7, অর্থাৎ rand() আটটি মান (0–7) সমান সম্ভাবনায় দেয়:

0r = 0  -> 0 % 6 = 0 -> face 11r = 1  -> 1 % 6 = 1 -> face 22r = 2  -> 2 % 6 = 2 -> face 33r = 3  -> 3 % 6 = 3 -> face 44r = 4  -> 4 % 6 = 4 -> face 55r = 5  -> 5 % 6 = 5 -> face 66r = 6  -> 6 % 6 = 0 -> face 1 again7r = 7  -> 7 % 6 = 1 -> face 2 again

তৃতীয়ত, rand() নিরাপত্তার কাজে একেবারেই চলবে না। OTP, পাসওয়ার্ড রিসেট লিংক, session token, এনক্রিপশনের key — এসব বানাতে হবে এমন উৎস থেকে, যা আগে থেকে অনুমান করা যায় না। rand()-এর সূত্র সাধারণত সরল, আর seed যদি time(NULL) হয়, আক্রমণকারী শুধু আনুমানিক সময় জানলেই কয়েক হাজার seed চেষ্টা করে আপনার “গোপন” OTP বের করে ফেলতে পারে।

৬ · math.h — দশমিকের হিসাব আর তার ফাঁদ

math.h-এর প্রায় সব ফাংশন double নেয় আর double ফেরত দেয়। একই ফাংশনের float রূপের নামের শেষে f (sqrtf), long double-এর শেষে l (sqrtl).

pow(10, 2) কেন কখনো 99 হয়ে যায়

একটি বহুল আলোচিত ঘটনা: কিছু পুরোনো compiler-library জুটিতে (বিশেষ করে পুরোনো MinGW-তে) (int)pow(10, 2) লিখলে 100-এর বদলে 99 আসত। কারণটা বুঝলে ফাঁদটা চিরদিনের জন্য মনে থাকবে:

1. pow সাধারণ ঘাতের জন্য বানানো — 2.7-এর 3.14 ঘাতও নিতে পারে। তাই ভেতরে অনেক সময় লগারিদমের মতো পথে হিসাব করে, পূর্ণসংখ্যা গুণ করে নয়।
2. সেই পথে ফল হতে পারে 99.99999999999997 — 100-এর খুব কাছে, কিন্তু একটু কম। (Floating-point-এর সীমাবদ্ধ precision, পর্ব ০৫।)
3. (int) cast গোল করে না, দশমিক অংশ কেটে ফেলে (truncation, পর্ব ০৮)। 99.999… কেটে হয় 99.

আধুনিক glibc-তে pow(10, 2) ঠিক 100 দেয়, কিন্তু শিক্ষাটা সব দশমিক হিসাবে খাটে। তিনটি নিয়ম মনে রাখুন:

• পূর্ণসংখ্যার ঘাত দরকার হলে লুপে গুণ করুন, বা পর্ব ৪৩-এর fast power. pow দশমিকের জন্য।
• দশমিক ফলকে int বানাতে হলে আগে round() বা lround(), তারপর রূপান্তর।
• দুটি দশমিক সমান কি না দেখতে == নয়; পার্থক্য খুব ছোট কি না দেখুন: fabs(a - b) < 1e-9.

৭ · time.h — সময়, তারিখ আর ২০৩৮ সালের সমস্যা

কম্পিউটার সময় রাখে খুব সরলভাবে: একটি নির্দিষ্ট মুহূর্ত থেকে এ পর্যন্ত কত সেকেন্ড পার হয়েছে, শুধু সেই সংখ্যাটি। সেই মুহূর্তটি হলো ১ জানুয়ারি ১৯৭০, রাত ১২টা (UTC) — নাম Unix epoch. time.h-এর মূল টাইপ ও ফাংশনগুলো এই সংখ্যাকে ঘিরে:

সময় অঞ্চল (time zone) নিয়ে চিন্তা নেই। বাংলাদেশের সময় UTC থেকে ৬ ঘণ্টা এগিয়ে। কিন্তু এই হিসাব আপনাকে করতে হয় না — OS-এর সেটিংস জানে আপনি কোন অঞ্চলে, আর localtime সেই অনুযায়ী স্থানীয় সময় দেয়। সার্ভারে সাধারণত সব সময় UTC-তে রাখা হয়, আর শুধু দেখানোর সময় স্থানীয় সময়ে বদলানো হয়।

কোড কতক্ষণ চলল মাপতে clock() সহজ উপায় — কাজের আগে ও পরে ডেকে পার্থক্য নিন। পর্ব ৩৯-এ Big-O-র তত্ত্ব আসল সময়ের সাথে মেলাতে এটি ব্যবহার করবেন। খেয়াল রাখুন, এটি দেয় CPU সময়, দেয়ালঘড়ির সময় নয় — প্রোগ্রাম ঘুমিয়ে থাকলে বা ইনপুটের অপেক্ষায় থাকলে সেই সময় গোনা হয় না।

strftime — format string দিয়ে তারিখ বানানো

রসিদে লিখতে চান “16 Oct 2026, 05:30 PM”. printf-এর মতোই strftime-এর format string-এ % দিয়ে শুরু হওয়া কোড বসে, আর প্রতিটি কোড struct tm-এর একটি ঘর থেকে মান নেয়। ধাপে ধাপে দেখুন লেখাটি কীভাবে তৈরি হয়:

1t.tm_year = 126;  /* 2026 - 1900 */2t.tm_mon  = 9;    /* 0 = Jan */3t.tm_mday = 16;4t.tm_hour = 17;   /* 24-hour */5t.tm_min  = 30;

এবার math.h আর time.h একসাথে চালিয়ে দেখুন। খেয়াল করুন, তারিখটি আমরা নিজেরা struct tm-এ বসিয়েছি — তাই প্রোগ্রাম যেদিনই চালান, ফল একই আসবে:

#include <stdio.h>
#include <math.h>
#include <time.h>

int main(void) {
    printf("sqrt(3*3 + 4*4) = %.1f\n", sqrt(3.0 * 3.0 + 4.0 * 4.0));
    printf("round(2.5)=%.0f  floor(-2.5)=%.0f  ceil(2.1)=%.0f\n",
           round(2.5), floor(-2.5), ceil(2.1));
    printf("fmod(10.5, 3) = %.1f\n", fmod(10.5, 3.0));

    struct tm t = {0};             /* a fixed date, not "now" */
    t.tm_year = 2026 - 1900;       /* years since 1900 */
    t.tm_mon  = 9;                 /* 0 = January, so 9 = October */
    t.tm_mday = 16;  t.tm_hour = 17;  t.tm_min = 30;
    t.tm_isdst = -1;               /* "not sure about daylight saving" */
    mktime(&t);                    /* fills in tm_wday (day of week) */

    char buf[64];
    strftime(buf, sizeof buf, "%a, %d %b %Y, %I:%M %p", &t);
    printf("%s\n", buf);
    return 0;
}

২০৩৮ সালের সমস্যা

পুরোনো অনেক সিস্টেমে time_t ছিল ৩২ বিটের signed পূর্ণসংখ্যা। এর সর্বোচ্চ মান 2147483647 সেকেন্ড। Epoch থেকে এতগুলো সেকেন্ড পূর্ণ হবে ১৯ জানুয়ারি ২০৩৮, UTC সময় রাত ৩টা ১৪ মিনিট ৭ সেকেন্ডে (বাংলাদেশ সময় সকাল ৯টা ১৪ মিনিট)। এর পরের সেকেন্ডে সংখ্যাটি wraparound হয়ে সবচেয়ে ছোট ঋণাত্মক মানে চলে যাবে — ঘড়ি দেখাবে ডিসেম্বর ১৯০১!

এর নাম Y2038 সমস্যা. আধুনিক ৬৪-বিট Linux, Windows আর Mac-এ time_t ইতিমধ্যে ৬৪ বিট, যা প্রায় ২৯ হাজার কোটি বছর চলবে। ঝুঁকি মূলত ৩২-বিটের পুরোনো এমবেডেড যন্ত্রে — রাউটার, শিল্পকারখানার নিয়ন্ত্রক, গাড়ির যন্ত্রাংশ — যেগুলো বহু বছর ধরে আপডেট ছাড়াই চলে। আর ফাইল ফরম্যাট বা ডেটাবেসে সময় যদি ৩২ বিটে জমা রাখা হয়, সেটাও একই ফাঁদে পড়বে।

৮ · সীমা, মাপ আর কিছু বিশেষ যন্ত্র

limits.h আর stdint.h — সংখ্যার মাপ নিশ্চিত করা

পর্ব ০৬-এ দেখেছেন, int কত বড় হবে তা C নির্দিষ্ট করে বলে না — শুধু বলে অন্তত ১৬ বিট। তাই “আমার যন্ত্রে সীমা কত” জানতে limits.h:

কখন কোনটা? সাধারণ গণনায় int ঠিক আছে। কিন্তু যেখানে মাপ চুক্তির অংশ — ফাইলের ফরম্যাট, নেটওয়ার্ক প্যাকেট, হার্ডওয়্যারের রেজিস্টার, হ্যাশের হিসাব — সেখানে stdint.h-এর টাইপ। আর যোগ বা গুণের আগে overflow হবে কি না যাচাই করতে INT_MAX-এর মতো সীমা: if (a > INT_MAX - b) মানে “যোগ করলে উপচে পড়বে”।

setjmp ও longjmp — অনেক দূরে লাফ

setjmp/longjmp জোড়াটি অদ্ভুত। setjmp বর্তমান অবস্থার একটি “বুকমার্ক” রাখে। পরে অনেকগুলো ফাংশনের গভীর থেকে longjmp ডাকলে প্রোগ্রাম সরাসরি সেই বুকমার্কে ফিরে আসে — মাঝের সব ফাংশন কোনো return ছাড়াই বাতিল হয়ে যায়। অনেকটা লুডোর সাপের মুখে পড়ে এক লাফে নিচে নেমে যাওয়ার মতো।

শুনতে শক্তিশালী, কিন্তু খুব কম ক্ষেত্রেই এটা ঠিক যন্ত্র। মাঝের ফাংশনগুলোর খোলা ফাইল বন্ধ হয় না, malloc করা মেমরি free হয় না, আর লাফের পরে কিছু local ভ্যারিয়েবলের মান অনির্ধারিত হতে পারে (যদি না সেগুলো volatile হয়)। কিছু parser, interpreter আর পুরোনো library ভুল-ব্যবস্থাপনায় এটি ব্যবহার করে। আপনার নিজের কোডে বেশিরভাগ সময় পর্ব ৩০-এর return code আর goto cleanup ধাঁচই ভালো।

signal.h — Ctrl+C ধরা

Terminal-এ চলমান প্রোগ্রামে Ctrl+C চাপলে OS প্রোগ্রামকে একটি signal পাঠায় — SIGINT. ডিফল্টভাবে প্রোগ্রাম সঙ্গে সঙ্গে বন্ধ হয়। signal.h দিয়ে নিজের একটি ফাংশন (signal handler) বসানো যায়, যেমন বন্ধ হওয়ার আগে ফাইল ঠিকমতো save করতে। তবে handler-এর ভেতরে নিয়ম খুব কড়া — printf বা malloc ডাকা নিরাপদ নয়; সাধারণত শুধু একটি volatile sig_atomic_t flag বসানো হয়, আর মূল লুপ সেটা দেখে। পূর্ণ আলোচনা পর্ব ৪৮-এ।

৯ · AI-এর যুগে — library-র ব্যাপারে AI যেসব ভুল করে

AI-কে C কোড লিখতে বললে সে দুই উল্টো রকম ভুল করে। কখনো library-র তৈরি ফাংশন থাকা সত্ত্বেও নিজে নতুন করে লেখে — নিজের হাতে বানানো my_atoi, নিজের bubble sort, নিজে লিপ ইয়ারের হিসাব — আর সেগুলোতে কোণার ক্ষেত্রে বাগ থাকে। আবার কখনো library ব্যবহার করে, কিন্তু ঠিক সেই ফাঁদগুলোতে পা দেয় যা এই পর্বে দেখলেন। কারণটা সহজ: AI শিখেছে ইন্টারনেটের অগণিত টিউটোরিয়াল থেকে, আর সেখানে atoi আর rand() % n-ই সবচেয়ে বেশি দেখা যায়।

শেষ সারির আগেরটা একটু ব্যাখ্যা দাবি করে। localtime ফল রাখে library-র ভেতরের একটি static struct tm-এ, আর তার ঠিকানা ফেরত দেয়। একটি থ্রেডে এটা ঠিক আছে। কিন্তু দুটি থ্রেড একসাথে ডাকলে একজনের ফল আরেকজন মুছে দিতে পারে — এমন ফাংশনকে বলে thread-safe নয় (thread-safety পর্ব ৪৯-এ)। localtime_r-এ আপনি নিজের struct tm-এর ঠিকানা দেন, তাই কোনো ভাগাভাগি নেই।

AI-এর কোডে library ব্যবহার যাচাইয়ের চেকলিস্ট

• নিজে লেখা কোনো ফাংশন কি আসলে library-তে আছে? থাকলে সেটাই ব্যবহার করেছি
• কোথাও atoi, atof নেই; সব রূপান্তরে strtol/strtod আর ভুলের যাচাই আছে
• ctype-এর প্রতিটি ডাকে (unsigned char) cast আছে
• srand একবারই ডাকা হয়েছে; নিরাপত্তার কাজে rand() নেই
• getenv, malloc, localtime-এর ফল NULL কি না যাচাই করা হয়েছে
• struct tm-এ মাস 0 থেকে আর বছর 1900 থেকে গোনা হয়েছে