টাইপ কনভার্শন — C যখন নীরবে মানের টাইপ বদলে দেয়

১ · নীরব অনুবাদক — C কেন নিজে থেকে টাইপ বদলায়

নাদিয়া একটি কোচিং সেন্টারের জন্য ছোট একটি প্রোগ্রাম লিখছেন। কাজ সহজ — তিনটি পরীক্ষার নম্বরের গড়, আর কতজন পাস করল তার শতকরা হার। একজন ছাত্রের নম্বর ৭৮, ৮৫ আর ৯০. হাতে হিসাব করলে গড় ৮৪.৩৩. প্রোগ্রাম দেখাল 84.00. আর ৫০ জনের মধ্যে ৪৫ জন পাস করলেও পাসের হার এলো 0.00!

কোনো error নেই, কোনো crash নেই। Compiler একটি warning-ও দেয়নি। অথচ দুটি ফলই ভুল। এই পর্বের মূল কথা এখানেই: C-এর বেশিরভাগ “রহস্যময়” বাগের পেছনে থাকে একটি লুকানো টাইপ বদল। পর্ব শেষে আপনি নাদিয়ার দুটি বাগই এক নজরে ধরতে পারবেন।

কেন বদলাতেই হয়

পর্ব ০৫-এ দেখেছেন, মেমরিতে সবকিছুই বিট। পর্ব ০৬-এ দেখেছেন, টাইপ হলো সেই বিটগুলো পড়ার চুক্তি — কত বিটের বাক্স, আর বিটগুলোর অর্থ কী। একটি char সাধারণত ৮ বিটের বাক্স, int ৩২ বিটের, double ৬৪ বিটের, এবং double-এর বিটগুলো একেবারে অন্য নিয়মে সাজানো (IEEE 754).

এখন CPU-র দিকটা ভাবুন। CPU-তে “৩২ বিটের পূর্ণসংখ্যা যোগ” একটি নির্দেশ, “৬৪ বিটের দশমিক যোগ” আরেকটি নির্দেশ। কিন্তু “একটি পূর্ণসংখ্যার সাথে একটি দশমিক যোগ” — এমন কোনো নির্দেশ নেই। তাই 3 + 2.5 লিখলে compiler-কে আগে দুটি মানকে একই টাইপে আনতে হয়। তারপর একটি নির্দেশে যোগ।

কোথায় কোথায় লুকিয়ে ঘটে

পর্ব ০৬-এ 7 / 2 আর একটি signed-unsigned তুলনার উদাহরণ দেখেছিলেন। এবার পুরো ছবিটা দেখি। C-তে টাইপ বদল ঘটে অন্তত ছয়টি জায়গায়:

আপনি না বললেও compiler নিজে যে বদল করে, তাকে বলে implicit conversion. আপনি নিজে বন্ধনীতে টাইপ লিখে যা করান, সেটি cast. দুটিই একই যন্ত্র ব্যবহার করে — পার্থক্য শুধু কে সিদ্ধান্ত নিচ্ছে।

২ · Integer promotion — ছোট বাক্স হিসাবে ঢোকার আগেই int

প্রথম নিয়মটি সবচেয়ে কম চোখে পড়ে, অথচ সবচেয়ে বেশি ঘটে। C কখনো char বা short-এর ওপর সরাসরি হিসাব করে না। হিসাবে ঢোকার আগেই এগুলো int হয়ে যায়। একে বলে integer promotion.

একটি ছোট পরীক্ষা: char a = 100, b = 100; তারপর int s = a + b; লিখলে s কত? char-এ ১২৭-এর বেশি ধরে না, তাই অনেকে ভাবেন ফল মুড়ে যাবে। কিন্তু ফল ঠিকঠাক 200. কারণ যোগের আগেই a আর b দুটিই int হয়েছে, আর int-এ 200 সহজেই আঁটে। এখানে promotion আপনাকে বাঁচাল।

আবার একই নিয়ম আপনাকে বিভ্রান্তও করতে পারে। sizeof(a + b) কত? 1 নয় — 4, কারণ a + b-এর টাইপ int.

প্রসারণের দুই পদ্ধতি — চিহ্ন টেনে আনা, নাকি শূন্য বসানো

৮ বিটকে ৩২ বিটে বাড়াতে হলে বাড়তি ২৪টি বিটে কিছু একটা বসাতে হয়। কী বসবে, তা নির্ভর করে মূল টাইপটি signed নাকি unsigned তার ওপর:

• Sign extension — signed টাইপে বাঁয়ের সবচেয়ে উঁচু বিটটি (sign bit) বাড়তি সব ঘরে কপি হয়। তাই −56 বড় বাক্সেও −56 থাকে।
• Zero extension — unsigned টাইপে বাড়তি সব ঘরে ০ বসে। তাই 200 বড় বাক্সেও 200 থাকে।

এবার একটি চতুর প্রশ্ন। C-এর মানদণ্ড বলেনি সাধারণ char signed হবে নাকি unsigned — এটি implementation-defined, অর্থাৎ প্রতিটি compiler ও প্ল্যাটফর্ম নিজে ঠিক করে এবং লিখে জানায়। Intel/AMD কম্পিউটারে (x86) GCC-তে char signed. কিন্তু ARM-ভিত্তিক Linux-এ (যেমন Raspberry Pi বা Android) সাধারণত unsigned. ফলে একই কোড দুই মেশিনে দুই উত্তর দিতে পারে। নিচের ডায়াগ্রামে দুটোই দেখুন:

1/* x86 + GCC: char is signed */2char c = 200;3int x = c + 1;4printf("%d\n", x);5/* ARM Linux: char is unsigned */

৩ · Usual arithmetic conversions — rank-এর সিঁড়ি

Promotion শেষ হলেও কাজ শেষ নয়। দুই পাশে এখনো আলাদা টাইপ থাকতে পারে — যেমন int আর double, বা int আর unsigned int. তখন C যে নিয়মে একটি সাধারণ টাইপ বেছে নেয়, তার নাম usual arithmetic conversions. এর কেন্দ্রে আছে প্রতিটি পূর্ণসংখ্যা টাইপের একটি পদমর্যাদা, যাকে বলে conversion rank.

খেয়াল করুন, একই ধাপে signed আর unsigned রূপ দুটিই থাকে — int আর unsigned int-এর rank সমান। এই ছোট্ট তথ্যটিই পরের সব ঝামেলার মূল। নিয়মটি ধাপে ধাপে চলে, আর প্রথম যে শর্ত মেলে সেখানেই থামে:

1. কোনো পাশে দশমিক টাইপ থাকলে, অন্য পাশও সেই দশমিক টাইপ হয় (সবচেয়ে উঁচুটি জেতে)। 3 + 2.5 → 3.0 + 2.5.
2. নইলে দুই পাশে integer promotion. তারপর টাইপ এক হলে কাজ শেষ।
3. দুটিই signed বা দুটিই unsigned হলে, নিচু rank-এরটি উঁচুতে ওঠে।
4. unsigned পাশের rank সমান বা বেশি হলে — signed-টি unsigned হয়ে যায়।
5. signed পাশের rank বেশি এবং সে unsigned-এর সব মান ধরতে পারলে — unsigned-টি signed হয়।
6. নইলে দুটিই signed টাইপটির unsigned রূপে যায়।

লিখে পড়লে জটিল লাগে। একটি উদাহরণে চালিয়ে দেখলে সহজ হয়ে যায়। পর্ব ০৬-এ দেখেছেন, -1 > 0u সত্য হয়। কিন্তু ঠিক কোন নিয়মে? পর্ব ০৭-এর শেষে প্রশ্নটি উল্টো দিক থেকে রেখেছিলাম — -1 < 0u কেন মিথ্যা? এবার নিয়মের প্রতিটি ধাপ ধরে দেখুন:

-1     → int (signed, ৩২ বিট)
0u     → unsigned int (u মানে unsigned)

দশমিক টাইপ আছে?          না
promotion দরকার?          না — দুটিই অন্তত int
টাইপ এক?                  না → পরের ধাপে

চিহ্ন একই?                না (একটি signed, একটি unsigned)
unsigned-এর rank ≥ signed-এর? হ্যাঁ (দুটিই int-এর ধাপে)
সিদ্ধান্ত:                 signed → unsigned int

বিট:  11111111 11111111 11111111 11111111
int হিসেবে পড়লে      = -1
unsigned হিসেবে পড়লে = 4294967295   (-1 + 4294967296)

4294967295 < 0    → 0   (মিথ্যা)
তাই  -1 < 0u       → 0

Linux 64-bit:  long = 64 bit → unsigned int-এর সব মান ধরে
               0u → 0L,  -1L < 0L  → 1 (সত্য)
Windows 64-bit: long = 32 bit → সব মান ধরে না
               দুটিই unsigned long → 0 (মিথ্যা)

৪ · Signed আর unsigned — size_t-এর ফাঁদ

“আমি তো unsigned লিখিই না, আমার কী ভয়?” — নতুনদের এই আত্মবিশ্বাস দ্রুত ভাঙে। কারণ unsigned টাইপ আপনার কোডে ঢোকে লাইব্রেরি থেকে, আপনার অজান্তে। সবচেয়ে বড় উৎস size_t: sizeof-এর ফল, strlen()-এর ফল, malloc()-এর আকার — সবই size_t, যা একটি unsigned টাইপ। ৬৪-বিট Linux-এ এটি ৬৪ বিটের unsigned long.

তিনটি পরিচিত ফাঁদ

তৃতীয় সমাধানটি একটু অদ্ভুত দেখায়, তাই একটু খুলে বলি। i-- > 0 আগে পুরোনো মান দিয়ে তুলনা করে, তারপর কমায়। n = ৩ হলে লুপের ভেতরে i পায় ২, ১, ০ — তারপর তুলনা 0 > 0 মিথ্যা, লুপ শেষ। আর n = ০ হলে একবারও ঢোকে না। প্রথমবার দেখলে অচেনা লাগে, কিন্তু অভিজ্ঞ C প্রোগ্রামাররা এটি চেনেন।

Compiler আপনার পাহারাদার — যদি তাকে জাগিয়ে রাখেন

GCC-তে এই ফাঁদগুলোর জন্য আলাদা warning আছে। -Wsign-compare signed আর unsigned তুলনা ধরলে সতর্ক করে — C-তে এটি -Wextra দিলেই চালু হয়। আর -Wtype-limits (এটিও -Wextra-এর অংশ) ধরে “unsigned ≥ ০ সবসময় সত্য” ধরনের শর্ত:

warning: comparison of integer expressions of different signedness: 'int' and 'size_t'
warning: comparison of unsigned expression in '>= 0' is always true

৫ · গড় আর শতকরা — integer division-এর আসল ক্ষতি

পর্ব ০৬-এ দেখেছেন 7 / 2 হয় 3, আর cast কোথায় বসালে ফল বাঁচে। এবার নাদিয়ার আসল প্রোগ্রামে ফিরি। এখানে দুটি আলাদা বাগ আছে, আর দ্বিতীয়টি প্রথমটির চেয়ে অনেক বিপজ্জনক — কারণ সেখানে ফল একটু ভুল নয়, পুরোপুরি শূন্য। ধাপে ধাপে দেখুন:

1int m1 = 78, m2 = 85, m3 = 90;2int sum = m1 + m2 + m3;3double avg = sum / 3;4double ok  = (double)sum / 3;5int passed = 45, total = 50;6double rate = passed / total * 100;7double fix  = 100.0 * passed / total;

আরেকটি বিকল্প আছে: পুরোটাই পূর্ণসংখ্যায় রেখে ক্রম বদলানো — passed * 100 / total দেয় 90. এটি তখনই ঠিক, যখন আপনি ইচ্ছা করেই দশমিক অংশ বাদ দিতে চান (যেমন ৮৯.৯%-কে ৮৯% দেখানো), আর গুণফল int-এর সীমা পার হয় না। দ্বিতীয় শর্তটি কতটা গুরুত্বপূর্ণ, তা দেখবেন অংশ ৭-এ।

৬ · মান বসানো আর cast — কাটা, মোড়ানো আর লুকানো বাগ

এখন পর্যন্ত দেখলাম হিসাবের ভেতরের রূপান্তর। এবার মান বসানোর সময়ের রূপান্তর — যেখানে ডান পাশের মানকে জোর করে বাঁ পাশের টাইপে ঢুকতে হয়। এখানে কোনো “সিঁড়ি” নেই; বাঁ পাশের টাইপই চূড়ান্ত। তাই এখানেই সবচেয়ে বেশি narrowing ঘটে।

পঞ্চম সারিটি অনেককে অবাক করে। float-এর ৩২ বিটের মধ্যে আসল অঙ্ক রাখার জায়গা মাত্র ২৪ বিটের সমান (precision). তাই ২^২৪ = ১,৬৭,৭৭,২১৬-এর পর থেকে প্রতিটি পূর্ণসংখ্যা আর হুবহু রাখা যায় না। ১ কোটি ৬৭ লাখের বেশি গ্রাহকের আইডি float-এ রাখলে দুজন আলাদা গ্রাহক একই আইডি পেয়ে যেতে পারেন। অর্থাৎ “বড় টাইপে যাচ্ছি” ভাবলেও int → float আসলে নিরাপদ নয়।

Cast — কখন বন্ধু, কখন ছদ্মবেশী শত্রু

Cast হলো compiler-কে আপনার স্পষ্ট নির্দেশ: “এই মানটিকে এই টাইপে বদলাও, আমি জানি কী করছি।” এটি তিনটি জায়গায় সত্যিই কাজের:

• হিসাবের টাইপ বদলাতে: (double)sum / 3 — ভাগের আগেই দশমিকে নেওয়া।
• গুণের আগে বড় বাক্সে নিতে: (long long)a * b — অংশ ৭-এ দেখবেন।
• উদ্দেশ্য স্পষ্ট করতে: int whole = (int)price; — “হ্যাঁ, দশমিক বাদ দেওয়াটাই চাই” — পাঠক আর compiler দুজনেই বোঝে।

কিন্তু cast কোনো জাদুর কাঠি নয়। এটি মান ঠিক করে না, শুধু বদলায়। দুটি সাধারণ ভুল ধারণা:

• “Cast গোল করে।” না। (int)2.99 হয় 2, (int)-2.99 হয় −2. গোল করতে চাইলে <math.h>-এর round() বা lround() আছে; সেগুলো পর্ব ২৬-এ স্ট্যান্ডার্ড লাইব্রেরির সাথে দেখবেন।
• “Cast দিলে warning চলে যায়, তাই সমস্যাও চলে যায়।” না। Warning চলে যায়, সমস্যা থেকে যায় — শুধু এখন আর কেউ দেখতে পায় না। (int)strlen(s) বা (unsigned)x দেখলে নিজেকে জিজ্ঞেস করুন: এখানে মান হারানো কি সম্ভব? সম্ভব হলে আগে পরিসীমা যাচাই করা হয়েছে কি?

printf-এর টাইপ — যেখানে কোনো রূপান্তরই হয় না

printf একটি variadic function — যত খুশি আর্গুমেন্ট নেয়, কিন্তু সেগুলোর টাইপ আগে থেকে জানে না। তাই এখানে C শুধু একটি সরল নিয়ম মানে, যার নাম default argument promotion: char আর short হয় int, float হয় double. ব্যস, আর কিছু না। এজন্যই float ছাপতেও %f চলে।

কিন্তু printf("%d", 3.5) লিখলে 3.5 মোটেই int হয় না। printf একটি int খুঁজবে, অথচ পাঠানো হয়েছে double. এটি undefined behavior. ৬৪-বিট Linux-এ double আর int আলাদা রেজিস্টারে পাঠানো হয়, তাই printf এমন একটি রেজিস্টার পড়ে যেখানে আপনার মান নেই — ছাপা হয় অর্থহীন কোনো সংখ্যা। সুখবর হলো, -Wall এটি ধরে (-Wformat): format '%d' expects argument of type 'int', but argument 2 has type 'double'.

এবার এতক্ষণের সব নিয়ম একসাথে চালিয়ে দেখুন। প্রতিটি লাইনের বাঁ পাশে লেবেল, ডান পাশে C-এর উত্তর:

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

int main(void) {
    int a = 7, b = 2, m = -1;
    unsigned int u = 0;
    double d = -3.99;
    char c = 'A';
    printf("7 / 2              = %d\n", a / b);
    printf("(double)7 / 2      = %.2f\n", (double)a / b);
    printf("(int)-3.99         = %d\n", (int)d);
    printf("sizeof(c + 1)      = %zu\n", sizeof(c + 1));
    printf("(unsigned)-1       = %u\n", (unsigned)m);
    printf("-1 < 0u ?          = %d\n", (unsigned)m < u);
    printf("strlen(\"Dhaka\") - 6 = %zu\n", strlen("Dhaka") - 6);
    printf("16777217 as float  = %.1f\n", (float)16777217);
    return 0;
}

৭ · গুণের আগেই overflow — বড় বাক্সে রাখলেও বাঁচা যায় না

অংশ ৫-এর মূল ধারণাটি এবার আরেকটি রূপে ফিরে আসছে, এবং এটি বাস্তবের সবচেয়ে ব্যয়বহুল বাগগুলোর একটি। ধরুন একটি মোবাইল ওয়ালেট কোম্পানির রিপোর্ট: ৫০,০০০ জন গ্রাহক, প্রত্যেকে গড়ে ৫০,০০০ পয়সা (৫০০ টাকা) পাঠিয়েছেন। মোট কত পয়সা? উত্তর ২৫০ কোটি — যা ৩২-বিট int-এর সর্বোচ্চ মান (প্রায় ২১৪ কোটি) ছাড়িয়ে যায়। প্রোগ্রামার সতর্ক, তাই ফল রাখলেন long long-এ। তবু ফল ভুল এলো। কেন?

int a = 50000, b = 50000;
long long x = a * b;      /* x তো ৬৪ বিট, তাহলে সমস্যা কী? */

a       *  b
int        int     → দুটিই int, গুণও int-এ (৩২ বিট)
আসল ফল    = 2500000000
int-এর সীমা = 2147483647   → সীমা পার!

মানদণ্ড বলে:  undefined behavior
অনেক মেশিনে বাস্তবে দেখা যায়:
2500000000 - 4294967296 = -1794967296
(optimizer চাইলে অন্য কিছুও করতে পারে)

x = (long long)(-1794967296)
x = -1794967296      → ৬৪ বিটে ভুল মানটিই নিখুঁতভাবে রাখা হলো

long long x = (long long)a * b;
a → long long;  b → long long (usual arithmetic conversions)
৬৪-বিট গুণ = 2500000000   ✔

long long x = (long long)(a * b);   /* ভুল! গুণ আগেই int-এ হয়ে গেছে */

৮ · দশমিকের রূপান্তর — সহনশীলতা আর টাকা-পয়সা

পর্ব ০৫-এ দেখেছেন কেন 0.1 + 0.2 হুবহু 0.3 হয় না: ১/১০ বাইনারিতে শেষ হয় না, যেমন ১/৩ দশমিকে শেষ হয় না (০.৩৩৩…)। ফলে 0.1 লিখলে মেমরিতে থাকে তার সবচেয়ে কাছের বাইনারি মান — 0.1000000000000000055…. এই পর্বের প্রশ্ন একটু ভিন্ন: এই ছোট্ট গরমিল টাইপ বদলের সময় কীভাবে বড় ভুলে পরিণত হয়?

প্রথম নিয়ম: দশমিকে == নয়

দুটি দশমিক সংখ্যা “সমান” কি না জানতে চাইলে জিজ্ঞেস করুন — “এরা কি যথেষ্ট কাছাকাছি?” এর জন্য একটি ছোট সহনশীলতা (tolerance) বেছে নিন:

#include <math.h>   /* fabs() = absolute value of a double */

if (fabs((0.1 + 0.2) - 0.3) < 1e-9) {
    /* close enough: treat as equal */
}

সহনশীলতা কত হবে, তা নির্ভর করে কাজের ওপর — মিটার মাপলে ১ মাইক্রোমিটার যথেষ্ট, জ্যোতির্বিদ্যায় হাজার কিলোমিটারও হতে পারে। খুব বড় বা খুব ছোট সংখ্যায় স্থির সহনশীলতার বদলে আপেক্ষিক সহনশীলতা লাগে; সেই গভীর আলোচনা ABCL TECH-এর Numerical Methods কোর্সে আছে।

দ্বিতীয় নিয়ম: টাকা গুনুন পয়সায়

এবার সবচেয়ে বাস্তব ক্ষেত্র — টাকা। একটি ছোট দোকানে দিনে ১,০০০টি ১০ পয়সার লেনদেন হলো। মোট হওয়ার কথা ঠিক ১০০ টাকা। তিনভাবে যোগ করে দেখি — float, double আর পয়সায় পূর্ণসংখ্যা। শেষ দুই লাইনে একটি টাইপ বদলের ফাঁদও আছে: ২৯ পয়সাকে টাকা থেকে পয়সায় নেওয়া।

#include <stdio.h>

int main(void) {
    float f = 0.0f;
    double d = 0.0;
    long long paisa = 0;
    for (int i = 0; i < 1000; i++) {   /* 1000 payments of Tk 0.10 */
        f += 0.10f;
        d += 0.10;
        paisa += 10;
    }
    printf("float  total: %.6f\n", f);
    printf("double total: %.15f\n", d);
    printf("paisa  total: %lld.%02lld\n", paisa / 100, paisa % 100);

    double price = 0.29;                 /* Tk 0.29 */
    printf("(int)(0.29 * 100)       = %d\n", (int)(price * 100));
    printf("(int)(0.29 * 100 + 0.5) = %d\n", (int)(price * 100 + 0.5));
    return 0;
}

৯ · AI-এর যুগে — টাইপ বদলের বাগ যা “চলে” কিন্তু ভুল

টাইপ কনভার্শনের বাগের একটি বৈশিষ্ট্য AI-এর লেখা কোডে এদের বিশেষ বিপজ্জনক করে তোলে: কোড compile হয়, চলে, এবং প্রায় সঠিক উত্তর দেয়। AI সাধারণত প্রচুর পুরোনো কোড দেখে শিখেছে, আর সেই কোডে এই ভুলগুলো অসংখ্যবার আছে। তার ওপর AI আপনার প্ল্যাটফর্মে char signed নাকি unsigned, long কত বিটের — তা জানে না।

AI সাধারণত যেসব টাইপ-ভুল করে

যাচাইয়ের চেকলিস্ট

• -Wall -Wextra দিয়ে শূন্য warning; হিসাবের কোডে -Wconversion চালু করেও প্রতিটি warning পড়েছি
• প্রতিটি /-এর জন্য জিজ্ঞেস করেছি: “ভাগের মুহূর্তে দুই পাশের টাইপ কী?”
• প্রতিটি বড় গুণের জন্য: “গুণফল কি int-এর সীমা পার হতে পারে? তাহলে গুণের আগেই বড় টাইপ”
• কোনো size_t বা strlen()-এর ফল ঋণাত্মক মানের সাথে তুলনা বা বিয়োগ হচ্ছে না
• টাকা পয়সায় পূর্ণসংখ্যা; দশমিক তুলনায় == নেই, সহনশীলতা আছে
• সীমার ইনপুট দিয়ে চালিয়েছি: ০, −১, খুব বড় সংখ্যা, খালি স্ট্রিং