আধুনিক C — C99 থেকে C23, কোন সংস্করণে কী এলো

১ · C কি ১৯৭৮ সালেই থেমে আছে?

অনেকের মনে একটি ধারণা আছে — C হলো “পুরোনো ভাষা”, Dennis Ritchie যেমন লিখে গেছেন, তেমনই রয়ে গেছে। ইন্টারনেটে খুঁজলে আজও এমন টিউটোরিয়াল পাবেন, যেখানে void main(), conio.h আর gets() দিয়ে C শেখানো হয়। কিন্তু সত্যিটা হলো, C একটি জীবন্ত ভাষা। প্রায় প্রতি দশকে এর নিয়ম হালনাগাদ হয়েছে, আর প্রতিবারই কোনো একটি বাস্তব কষ্ট দূর করা হয়েছে।

এই কোর্সে এতক্ষণ আপনি যে C লিখেছেন, সেটি আসলে বেশ আধুনিক C. for (int i = 0; …) লেখা, // দিয়ে মন্তব্য, int32_t, bool — এগুলোর কোনোটিই ১৯৭৮ সালের C-তে ছিল না। এই পর্বে আমরা পেছনে ফিরে দেখব কোন জিনিস কবে, কেন এলো। তাতে দুটি বড় লাভ হবে। এক, পুরোনো বা অন্যের লেখা কোড পড়লে বুঝবেন সেটি কোন যুগের। দুই, নিজের প্রজেক্টে সচেতনভাবে একটি স্ট্যান্ডার্ড বেছে নিতে পারবেন।

২ · সময়রেখা — K&R থেকে C23

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

একটি বিষয় খেয়াল করুন। নামের সংখ্যা আর প্রকাশের বছর সবসময় মেলে না। C17 প্রকাশ পায় ২০১৮ সালে, আর C23-এর আনুষ্ঠানিক নাম ISO/IEC 9899:2024 — প্রকাশ ২০২৪ সালে। নামটি এসেছে কাজ শেষ হওয়ার আনুমানিক বছর থেকে। এজন্য C17-কে কেউ কেউ C18-ও বলেন।

আপনার compiler কোন স্ট্যান্ডার্ড মানছে?

GCC ও Clang-এ -std= flag দিয়ে স্ট্যান্ডার্ড বেছে নেওয়া যায়। দুই রকম নাম আছে: c11, c17, c23 মানে “শুধু স্ট্যান্ডার্ড মেনে চলো”; আর gnu11, gnu17, gnu23 মানে “স্ট্যান্ডার্ড, তার সাথে GCC-র নিজস্ব বাড়তি সুবিধা” — যাকে বলে GNU extension.

gcc -std=c11 -Wall -Wextra -pedantic main.c -o main   # কঠোরভাবে C11
gcc -std=c23 -Wall -Wextra main.c -o main             # C23 মেনে
gcc -dM -E -x c /dev/null | grep STDC_VERSION         # ডিফল্ট কোনটি দেখুন

-pedantic যোগ করলে স্ট্যান্ডার্ডের বাইরের কিছু লিখলেই compiler warning দেয়। কোড অন্য compiler-এ নেওয়ার পরিকল্পনা থাকলে এটি খুব কাজের। আর কোডের ভেতর থেকে স্ট্যান্ডার্ড জানতে আছে __STDC_VERSION__ — একটি predefined macro, যা পর্ব ২৭-এ এক ঝলক দেখেছেন। এর মান সংখ্যা, তাই #if __STDC_VERSION__ >= 201112L লিখে “C11 বা নতুন হলে” শর্ত দেওয়া যায়।

একই প্রোগ্রাম, চার যুগে

কথার চেয়ে চোখে দেখা ভালো। নিচে একটি ছোট প্রোগ্রাম — ১ থেকে ৩ পর্যন্ত যোগ — চারটি যুগের লেখারীতিতে দেখানো হলো। “পরে” চাপুন এবং প্রতি ধাপে কী বদলাল, তা খেয়াল করুন।

add(a, b)          /* ফেরত টাইপ নেই = int ধরে নেওয়া */
int a, b;          /* প্যারামিটারের টাইপ আলাদা লাইনে */
{
    return a + b;
}

main()
{
    int i, total;
    total = 0;
    for (i = 1; i <= 3; i++)
        total = add(total, i);
    printf("%d\n", total);   /* header ছাড়াই */
}

#include <stdio.h>

int add(int a, int b)   /* টাইপসহ প্যারামিটার */
{
    return a + b;
}

int main(void)
{
    int i, total;          /* সব ঘোষণা ব্লকের শুরুতে */
    total = 0;
    for (i = 1; i <= 3; i++)
        total = add(total, i);
    printf("%d\n", total);
    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>

static inline int32_t add(int32_t a, int32_t b) { return a + b; }

int main(void) {
    int32_t total = 0;                // নতুন ধাঁচের মন্তব্য
    for (int i = 1; i <= 3; i++)      // i শুধু লুপের ভেতরে
        total = add(total, i);
    bool ok = (total == 6);
    printf("%d %d\n", (int)total, ok);
    return 0;
}

#include <stdio.h>
#include <stdint.h>
                                      // stdbool.h আর লাগে না
[[nodiscard]] static inline int32_t add(int32_t a, int32_t b) { return a + b; }

int main(void) {
    constexpr int N = 3;
    int32_t total = 0;
    for (int i = 1; i <= N; i++)
        total = add(total, i);
    bool ok = (total == 6);           // bool এখন সরাসরি keyword
    static_assert(sizeof(int32_t) == 4);
    printf("%d %d\n", (int)total, ok);
    return 0;
}

৩ · C99 — আধুনিক C-এর আসল শুরু

C89 থেকে C99 পর্যন্ত দশ বছরে প্রোগ্রামিং জগৎ অনেক বদলে যায়। ৬৪-বিট কম্পিউটার আসছে, বৈজ্ঞানিক গণনায় C-কে Fortran-এর সাথে পাল্লা দিতে হচ্ছে, আর C++ থেকে কিছু ভালো ধারণা (যেমন // মন্তব্য, inline) C-তে আনার দাবি উঠছে। C99 ছিল সেই চাপের জবাব। এই কোর্সে আপনি অনেকগুলো আগেই ব্যবহার করেছেন:

তালিকায় আরও আছে: snprintf (বাফারের মাপ জেনে লেখে — পর্ব ১৯), stdbool.h, __func__ (বর্তমান ফাংশনের নাম), variadic macro আর complex সংখ্যা। কিন্তু এর মধ্যে দুটি জিনিস একটু আলাদা মনোযোগ দাবি করে, কারণ এগুলো নতুনরা প্রায়ই চেনেন না: compound literal আর flexible array member.

Compound literal — নাম ছাড়া একটি struct

ধরুন একটি ফাংশন struct point নেয়। C89-এ আগে একটি ভ্যারিয়েবল বানাতে হতো, মান বসাতে হতো, তারপর পাঠাতে হতো। C99-এ সরাসরি লেখা যায় show((struct point){ .x = 3, .y = 7 }); — বন্ধনীর ভেতরে টাইপ, তারপর শুরুর মান। এটি একটি আসল object তৈরি করে, যার নাম নেই। ফাংশনের ভেতরে লিখলে এটি সেই ব্লকের শেষ পর্যন্ত বাঁচে, ঠিক সাধারণ local ভ্যারিয়েবলের মতো।

Flexible array member — header আর ডেটা এক টুকরোয়

নেটওয়ার্কের একটি মেসেজের কথা ভাবুন: শুরুতে দৈর্ঘ্য, তারপর যত খুশি byte. পুরোনো উপায়ে struct-এ একটি pointer রাখা হতো, আর ডেটার জন্য আলাদা malloc করতে হতো — অর্থাৎ দুটি বরাদ্দ, দুটি free, আর একটি ভুলে গেলেই memory leak. C99 একটি সুন্দর সমাধান দিল: struct-এর শেষ member হিসেবে মাপ ছাড়া অ্যারে।

struct msg {
    size_t len;     // কত byte ডেটা
    char data[];    // flexible array member — মাপ নেই, শেষে থাকতেই হবে
};

struct msg *m = malloc(sizeof *m + n + 1);   // header + n byte + '\0'

এখানে sizeof *m শুধু header-এর মাপ দেয় — data এই হিসাবে কোনো জায়গা নেয় না। তার সাথে যত byte যোগ করবেন, data ততটা লম্বা হবে। নিচের ডায়াগ্রামে মেমরিতে কী ঘটে, ধাপে ধাপে দেখুন।

sizeof(struct msg) == 8

┌──────────────┬
│ len (8 byte) │ data[] → এখনো ০ byte
└──────────────┴
data শুধু একটি “চিহ্ন”: header যেখানে শেষ, ডেটা সেখান থেকে শুরু

m ──►┌──────────────┬────────────────────────────┐
     │ len  (8)     │ data (22 + 1 = 23 byte)    │
     └──────────────┴────────────────────────────┘
     একটিই ধারাবাহিক মেমরি ব্লক — মোট 31 byte

m ──►┌──────────────┬────────────────────────────┐
     │ len = 22     │ b K a s h :   5 0 0 ... \0 │
     └──────────────┴────────────────────────────┘
     header-এর ঠিক পরেই ডেটা — cache-এর জন্যও ভালো

Flexible array:  malloc ×1   free ×1
Pointer member:   malloc ×2   free ×2   (একটি ভুললেই leak)

ভুল: struct msg x;  // stack-এ বানালে data-র জন্য জায়গাই নেই

এবার তিনটি C99 জিনিস একসাথে চালিয়ে দেখুন — designated initializer, compound literal আর flexible array member. প্রথম লাইনে আপনার compiler কোন স্ট্যান্ডার্ড ব্যবহার করছে, সেটিও ছাপা হবে।

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct point { int x, y; };
struct msg { size_t len; char data[]; };   // flexible array member

static void show(struct point p) { printf("point: x=%d y=%d\n", p.x, p.y); }

int main(void) {
    printf("__STDC_VERSION__ = %ld\n", (long)__STDC_VERSION__);
    show((struct point){ .y = 7, .x = 3 });   // compound literal
    const char *text = "bKash: 500 Tk received";
    size_t n = strlen(text);
    struct msg *m = malloc(sizeof *m + n + 1);
    if (m == NULL) return 1;
    m->len = n;
    memcpy(m->data, text, n + 1);
    printf("len=%zu data=%s\n", m->len, m->data);
    free(m);
    return 0;
}

৪ · C11 — টাইপ-বুদ্ধি, নিরাপত্তা আর একাধিক core

২০০০-এর দশকে কম্পিউটারের গতি বাড়ানোর পথ বদলে যায়। এক core-কে আরও দ্রুত না করে কোম্পানিগুলো একটি চিপে একাধিক core বসাতে শুরু করে। কিন্তু C স্ট্যান্ডার্ডে তখনো “thread” বলে কিছু ছিল না — সবাই নিজের OS-এর library (যেমন POSIX-এর pthread) ব্যবহার করত, আর স্ট্যান্ডার্ড মেমরি মডেল না থাকায় একসাথে চলা কোডের আচরণ ঠিকমতো বলা যেত না। একই সময়ে buffer overflow-জনিত নিরাপত্তা-ত্রুটি বড় মাথাব্যথা হয়ে দাঁড়ায়। C11 এই দুই দিকেই কাজ করেছে।

লক্ষ করুন, নতুন keyword-গুলো দেখতে অদ্ভুত — underscore আর বড় হাতের অক্ষর দিয়ে শুরু (_Generic, _Noreturn). কারণটি backward compatibility. লক্ষ লক্ষ পুরোনো প্রোগ্রামে কেউ হয়তো noreturn বা alignas নামে ভ্যারিয়েবল রেখেছেন। নতুন keyword সেই নাম কেড়ে নিলে সেসব কোড ভেঙে যেত। আর _ + বড় হাতের অক্ষর দিয়ে শুরু নাম C-তে আগে থেকেই স্ট্যান্ডার্ডের জন্য সংরক্ষিত, সাধারণ প্রোগ্রামারের ব্যবহারের অনুমতি ছিল না। সুন্দর নাম চাইলে header ছিল — stdalign.h দিলে alignas, stdnoreturn.h দিলে noreturn.

gets() কেন স্ট্যান্ডার্ড থেকেই মুছে ফেলা হলো

gets(buf) জানেই না buf কত বড়। ব্যবহারকারী যত লম্বা লাইন দেবেন, ততটাই লিখে যাবে — বাফারের বাইরেও। ১৯৮৮ সালের বিখ্যাত Morris worm যেসব দুর্বলতা দিয়ে ছড়িয়েছিল, তার একটি ছিল fingerd প্রোগ্রামে gets-এর ব্যবহার। C99-এর পরের সংশোধনীতে একে deprecated ঘোষণা করা হয়, আর C11 একে পুরোপুরি বাদ দেয়। স্ট্যান্ডার্ড থেকে কোনো ফাংশন মুছে ফেলা প্রায় অভূতপূর্ব ঘটনা — এতেই বোঝা যায় বিপদ কত বড় ছিল।

_Generic — C-তে টাইপ অনুযায়ী আচরণ

C-তে একই নামে দুটি ফাংশন রাখা যায় না (C++-এর মতো overloading নেই)। তাই গণিতের library-তে sqrt, sqrtf, sqrtl — তিনটি আলাদা নাম। C99 tgmath.h-এ “type-generic” sqrt দিয়েছিল, কিন্তু সাধারণ প্রোগ্রামার নিজে এমন জিনিস বানাতে পারতেন না। C11-এর _Generic সেই ক্ষমতা সবার হাতে দিল। এটি compile করার সময় একটি expression-এর টাইপ দেখে তালিকা থেকে একটি বিকল্প বেছে নেয় — চলার সময় কোনো খরচ নেই। নিচের ডায়াগ্রামে দেখুন কোন আর্গুমেন্টে কোন শাখা বাছাই হয়।

1#define print_any(x) _Generic((x), \2    int:    print_int,    \3    double: print_double, \4    char *: print_str)(x)56char city[] = "Dhaka";7print_any(42);8print_any(3.14159);9print_any(city);10print_any('A');11print_any(2.5f);

এবার আসল কোডটি চালিয়ে দেখুন। সাথে আছে একটি _Static_assert — এটি নিশ্চিত করে যে int32_t সত্যিই ৪ byte; না হলে প্রোগ্রাম তৈরিই হবে না।

#include <stdio.h>
#include <stdint.h>

static void print_int(int v)       { printf("int    : %d\n", v); }
static void print_double(double v) { printf("double : %.2f\n", v); }
static void print_str(char *s)     { printf("string : %s\n", s); }

#define print_any(x) _Generic((x), \
    int:    print_int,             \
    double: print_double,          \
    char *: print_str)(x)

_Static_assert(sizeof(int32_t) == 4, "int32_t must be 4 bytes");

int main(void) {
    char city[] = "Dhaka";
    print_any(42);
    print_any(3.14159);
    print_any(city);
    print_any('A');
    return 0;
}

Annex K — ভালো উদ্দেশ্য, ব্যর্থ বাস্তবায়ন

C11 একটি ঐচ্ছিক অংশ যোগ করেছিল — Annex K, যেখানে strcpy_s, strcat_s, gets_s-এর মতো ফাংশন আছে, যারা গন্তব্যের মাপ নেয় এবং সীমা পার হলে একটি “constraint handler” ডাকে। ধারণাটি মূলত Microsoft-এর। কিন্তু সমস্যা হলো, Microsoft-এর নিজের বাস্তবায়ন স্ট্যান্ডার্ডের সাথে পুরোপুরি মেলে না, আর glibc বা musl-এর মতো বড় open-source library এটি বানায়নি। ফলে Annex K দিয়ে লেখা কোড প্রায় কোথাও portable নয়। ২০১৫ সালে কমিটিতে জমা দেওয়া একটি অভিজ্ঞতা-প্রতিবেদন এটিকে বাদ দেওয়ার প্রস্তাবও করেছিল। আজও এটি ঐচ্ছিক অংশ হিসেবে রয়ে গেছে, কিন্তু বাস্তবে খুব কম ব্যবহৃত। (ভাবনার প্রশ্ন ৩-এ বিস্তারিত।)

৫ · C17 আর C23 — বিরতি, তারপর বড় সংস্কার

C17 নিয়ে বলার কথা কম, আর সেটাই এর পরিচয়। এটি C11-এর ভেতরে পাওয়া অস্পষ্টতা ও ভুলগুলোর (defect report) সমাধান — নতুন কোনো বৈশিষ্ট্য নেই। বহু বছর GCC-র ডিফল্ট ছিল gnu17, তাই আজকের বেশিরভাগ চালু প্রজেক্ট কার্যত C17-এ লেখা।

C23 এর ঠিক উল্টো — অনেক বছরের মধ্যে সবচেয়ে বড় পরিবর্তন। এর একটি বড় অংশ হলো দীর্ঘদিন ধরে compiler-গুলোর extension হিসেবে থাকা জিনিসকে স্ট্যান্ডার্ডে তোলা, আর C++-এর সাথে কিছু লেখারীতি মিলিয়ে নেওয়া। প্রধান সংযোজনগুলো দেখুন:

কয়েকটি জিনিস একসাথে দেখতে এমন দেখায় (এই অংশটি শুধু পড়ার জন্য; C23-সমর্থিত compiler-এ চলে):

#include <stdbit.h>

constexpr unsigned MASK = 0b1111'0000;         // binary + digit separator
[[nodiscard]] int save_file(const char *path); // ফল উপেক্ষা করলে warning

void demo(int *p) {
    if (p == nullptr) return;                  // nullptr, NULL নয়
    typeof(*p) copy = *p;                      // copy-র টাইপ int
    auto bits = stdc_count_ones(MASK);         // কয়টি 1-বিট? 4
    struct { int a, b; } pair = {};            // সব শূন্য
    (void)copy; (void)bits; (void)pair;
}

যা চলে গেছে বা বদলে গেছে

C23 শুধু যোগ করেনি, কিছু পুরোনো জিনিস সরিয়েও দিয়েছে। এগুলো জানা জরুরি, কারণ পুরোনো কোড বা AI-এর কোড এখানেই আটকাতে পারে:

• K&R ধাঁচের ফাংশন সংজ্ঞা বাদ। int add(a, b) int a, b; {…} আর স্ট্যান্ডার্ড C নয়। তবে GCC এখনো gnu মোডে এটি মেনে নেয়, শুধু old-style function definition warning দেয় — বহু পুরোনো কোড যাতে হঠাৎ ভেঙে না যায়।
• int f();-এর অর্থ বদলেছে। আগে খালি বন্ধনী মানে ছিল “প্যারামিটার সম্পর্কে কিছু বলছি না”, তাই f(1, 2, 3) ডাকলেও compiler চুপ থাকত। C23-এ () মানে (void) — কোনো প্যারামিটার নেই, ঠিক C++-এর মতো।
• Two's complement বাধ্যতামূলক। আগে স্ট্যান্ডার্ড ঋণাত্মক সংখ্যার তিন রকম উপস্থাপন মেনে নিত (sign-magnitude, ones' complement, two's complement). বাস্তবে কয়েক দশক ধরে সব যন্ত্র two's complement ব্যবহার করে, তাই C23 এটিকেই একমাত্র নিয়ম করেছে (পর্ব ০৫)। খেয়াল করুন: signed overflow এখনো undefined behavior — পর্ব ৪৬-এর আলোচনা বদলায়নি।

৬ · Compile-এর সময় যাচাই বনাম চলার সময় যাচাই

আধুনিক C-এর একটি বড় শিক্ষা হলো: যত আগে ভুল ধরা পড়ে, তত কম খরচ। static_assert আর assert (পর্ব ৩০) দেখতে প্রায় এক, কিন্তু কাজ করে দুই ভিন্ন সময়ে। একটি ধরে প্রোগ্রাম তৈরির আগে, অন্যটি প্রোগ্রাম চলার সময় — তাও যদি সেই লাইনে পৌঁছানো হয়। নিচে একটি ধারণা দুই ভাবে যাচাই করা দেখুন: “আমাদের ফাইল-ফরম্যাটের header ঠিক ১৬ byte হতে হবে।”

#include <assert.h>
#include <stdint.h>

struct file_header { uint32_t magic; uint32_t ver; uint64_t size; };

static_assert(sizeof(struct file_header) == 16, "header must be 16 bytes");

void read_header(const struct file_header *h) {
    assert(h != NULL);      // চলার সময় যাচাই
    ...
}

$ gcc -c header.c
header.c:6:1: error: static assertion failed: "header must be 16 bytes"

→ কোনো .o বা executable তৈরি হয়নি। ভুল ব্যবহারকারীর কাছে পৌঁছানোর প্রশ্নই নেই।

$ ./reader
reader: header.c:9: read_header: Assertion `h != NULL' failed.
Aborted (core dumped)

→ ধরা পড়ল, কিন্তু শুধু তখনই যখন এই পথটি সত্যিই চলল।

static_assert  → এখনো যাচাই হয় (compile-এর সময়)
assert(...)    → পুরোপুরি মুছে যায় — কোনো যাচাই নেই

তাই assert-এর ভেতরে কখনো দরকারি কাজ (যেমন i++) রাখবেন না।

৭ · “আধুনিক C” স্টাইল — কিন্তু portable

নতুন বৈশিষ্ট্য জানা এক কথা, সেগুলো দিয়ে ভালো কোড লেখা আরেক কথা। আজকের পেশাদার C প্রজেক্টগুলো — Linux kernel থেকে SQLite, curl, Redis — নিজেদের মতো নিয়ম মেনে চলে, তবে কিছু অভ্যাস প্রায় সবখানেই দেখা যায়:

সাথে আরও দুটি অভ্যাস: অনুমানগুলো static_assert দিয়ে লিখে রাখা, আর build-এ কড়া warning চালু রাখা — -std=c17 -Wall -Wextra -pedantic, debug build-এ sanitizer (পর্ব ৩১)। মনে রাখবেন, “আধুনিক” মানে নতুনতম সব বৈশিষ্ট্য গুঁজে দেওয়া নয়। মানে হলো এমন কোড, যা পড়তে সহজ, ভুল করা কঠিন, আর compiler যেটা যাচাই করতে পারে।

Portability — সবাই একই গতিতে এগোয় না

আপনার কোড কোথায় compile হবে, তার ওপর নির্ভর করে কোন স্ট্যান্ডার্ড বাছবেন। GCC ও Clang সাধারণত নতুন স্ট্যান্ডার্ড দ্রুত গ্রহণ করে। কিন্তু Microsoft-এর MSVC বহু বছর ধরে মূলত C++-এর দিকে মনোযোগ দিয়েছিল; C99-এর অনেক অংশও সেখানে দেরিতে এসেছে। ২০২০ সালের দিকে Visual Studio 2019-এর একটি আপডেটে /std:c11 ও /std:c17 যোগ হয়, তবে VLA-র মতো ঐচ্ছিক অংশ বাদ রেখে। Embedded জগতের অনেক বিক্রেতার compiler আজও C99 বা তারও পুরোনো স্ট্যান্ডার্ডে আটকে থাকতে পারে (পর্ব ৫১)।

তাই বাস্তব কৌশল হলো: একটি ন্যূনতম স্ট্যান্ডার্ড ঠিক করুন (অনেক library-র জন্য আজ সেটি C11 বা C17), আর নতুন কিছু ব্যবহার করতে চাইলে শর্তসাপেক্ষে করুন:

#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
    #define NODISCARD [[nodiscard]]
#elif defined(__GNUC__)
    #define NODISCARD __attribute__((warn_unused_result))
#else
    #define NODISCARD
#endif

NODISCARD int save_file(const char *path);

এভাবে C23-সমর্থিত compiler-এ নতুন attribute, পুরোনো GCC/Clang-এ তাদের নিজস্ব রূপ, আর অন্য সবখানে কিছুই না — কোড সবখানে compile হয়। বড় open-source library-গুলো ঠিক এই কৌশলে চলে।

৮ · AI-এর যুগে — স্ট্যান্ডার্ড গুলিয়ে ফেলা কোড

AI মডেল শিখেছে ইন্টারনেটের কোটি কোটি লাইন কোড থেকে — যেখানে ১৯৯০-এর টিউটোরিয়াল, আধুনিক GitHub প্রজেক্ট আর C++ কোড সব মিলেমিশে আছে। ফলে AI-এর লেখা একটি C ফাইলে একসাথে তিন যুগের জিনিস দেখা খুব সাধারণ ঘটনা। সমস্যা হলো, এমন কোড এক compiler-এ চলে, আরেকটিতে চলে না — আর আপনি বুঝতেই পারবেন না কেন।

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

• নিজের লক্ষ্য-স্ট্যান্ডার্ড দিয়ে compile করেছি: -std=c17 -pedantic (বা যেটি প্রজেক্টে ঠিক করা) — একটিও warning নেই
• কোনো C++ চিহ্ন নেই — new, class, ::, & দিয়ে reference, malloc-এর আগে অপ্রয়োজনীয় cast
• gets, void main, conio.h, _s ফাংশন নেই
• C23-এর কিছু থাকলে (nullptr, constexpr, [[...]]) — সেটি জেনেবুঝে, আর লক্ষ্য-compiler সত্যিই সমর্থন করে
• অন্তত দুটি compiler-এ (যেমন GCC ও Clang) চালিয়ে দেখেছি, অথবা godbolt.org-এ পুরোনো GCC সংস্করণ বেছে পরীক্ষা করেছি