অপারেটর — C যেভাবে হিসাব করে, তুলনা করে আর যুক্তি সাজায়

১ · অপারেটর কী — এক্সপ্রেশনের ব্যাকরণ

আগের পর্বে আমরা ভ্যারিয়েবল বানিয়েছি — ডেটা রাখার বাক্স। কিন্তু বাক্সে জিনিস রেখে দিলেই কাজ হয় না। দোকানদার শুধু খাতায় দাম লিখে রাখলে বিক্রি হয় না — তাকে যোগ করতে হয়, ছাড় বাদ দিতে হয়, দেখতে হয় খদ্দেরের টাকা যথেষ্ট কি না। এই “করা”-র কাজগুলোই প্রোগ্রামে করে operator.

একটি ছোট লাইন দেখুন: total = price * qty + 20. এখানে *, + আর = হলো অপারেটর। যাদের ওপর এরা কাজ করছে — price, qty, 20 — তারা operand. আর অপারেটর ও operand মিলে যে পুরো অংশটি হিসাব শেষে একটি মান দেয়, তার নাম expression.

কিছু অপারেটর একটিমাত্র operand নেয় — যেমন -x বা !ok. এদের বলে unary. বেশিরভাগ নেয় দুটি — যেমন a + b; এরা binary. পুরো C ভাষায় অপারেটর আছে চল্লিশের কাছাকাছি, কিন্তু এগুলোকে পাঁচটি পরিবারে ভাগ করলে মনে রাখা সহজ:

২ · হিসাবের অপারেটর — আর ভাগশেষের জাদু

যোগ (+), বিয়োগ (-) আর গুণ (*) স্কুলের অঙ্কের মতোই চলে। নতুনত্ব দুটি জায়গায় — ভাগ আর ভাগশেষ।

পূর্ণসংখ্যার ভাগ: দশমিক হারিয়ে যায়

পর্ব ০৬-এ দেখেছেন, দুটি int ভাগ করলে ফলও int হয়। একে বলে integer division. 7 / 2-এর ফল ৩, সাড়ে তিন নয় — দশমিক অংশটি স্রেফ কেটে ফেলা হয়, গোল করা হয় না। তাই 9 / 10-এর ফল ০। দশমিকসহ উত্তর চাইলে অন্তত একটি operand দশমিক সংখ্যা হতে হবে, যেমন 7.0 / 2, যার ফল ৩.৫।

ভাগশেষ %: ছোট চিহ্ন, বড় কাজ

%-কে বলে modulus অপারেটর — এটি ভাগের পর যা বাকি থাকে তা দেয়। ধরুন ১৭টি বিস্কুট ৫ জন শিশুর মধ্যে সমান ভাগ করবেন। প্রত্যেকে পাবে 17 / 5 = ৩টি, আর বাকি থাকবে 17 % 5 = ২টি। শুধু এটুকু দিয়েই অনেক বাস্তব সমস্যার সমাধান হয়:

একটি সূক্ষ্ম বিষয়: ঋণাত্মক সংখ্যায় C99 থেকে নিয়ম হলো — ভাগফল সবসময় শূন্যের দিকে কাটা হয়। তাই -7 / 2 = -3, আর ভাগশেষের চিহ্ন হয় ভাজ্যের (বাঁ পাশের সংখ্যার) মতো: -7 % 2 = -1. অর্থাৎ n % 2 == 1 দিয়ে বিজোড় যাচাই করলে ঋণাত্মক বিজোড় সংখ্যায় ভুল উত্তর আসবে! নিরাপদ লেখা হলো n % 2 != 0. আর একটি কথা — % শুধু পূর্ণসংখ্যায় চলে; দশমিক সংখ্যায় ভাগশেষ লাগলে fmod() ফাংশন আছে।

৩ · মান বসানো, বাড়ানো, কমানো — =, +=, ++

গণিতে x = x + 1 লিখলে শিক্ষক লাল কালি দেবেন — কোনো সংখ্যা নিজের চেয়ে ১ বেশি হতে পারে না। কিন্তু C-তে = মানে “সমান” নয়। এর মানে “ডান পাশ হিসাব করো, তারপর ফলটি বাঁ পাশের বাক্সে রাখো।” একে বলে assignment. তাই x = x + 1 মানে — x-এর পুরোনো মানে ১ যোগ করে নতুন মানটি আবার x-এ রাখো।

যেহেতু assignment-ও একটি expression, তার নিজেরও মান আছে — যে মানটি বসানো হলো সেটাই। এ কারণে a = b = 0; লেখা যায়: আগে b = 0 হয়, তার মান ০, সেটি যায় a-তে। আবার এ কারণেই পর্ব ০৩-এর সেই বাগটি ঘটে — if (marks = 100) তুলনা করে না, 100 বসিয়ে দেয়, আর 100 শূন্য নয় বলে শর্ত সবসময় সত্য।

সংক্ষিপ্ত রূপ: +=, -=, *= …

“নিজের সাথে কিছু করে আবার নিজেতেই রাখা” এত বেশি লাগে যে C-তে এর জন্য আলাদা লেখা আছে — compound assignment. balance -= 500 মানে balance = balance - 500, যেমন bKash থেকে ৫০০ টাকা ক্যাশ-আউট। একইভাবে +=, *=, /=, %=, এমনকি বিটের জন্য |=, &=.

++ আর --: আগে না পরে?

১ বাড়ানো (++) আর ১ কমানো (--) এত সাধারণ কাজ যে এদের জন্য আলাদা অপারেটর আছে — increment ও decrement. গোলমাল একটাই: চিহ্নটি ভ্যারিয়েবলের আগে বসবে, না পরে?

একা একটি লাইনে i++; আর ++i; — দুটোর ফল একদম এক। পার্থক্য শুধু তখনই, যখন এরা একটি বড় expression-এর ভেতরে বসে। এখানেই লুকিয়ে আছে C-র সবচেয়ে কুখ্যাত ফাঁদগুলোর একটি।

i = i++ কেন undefined

i++ দুটি কাজ করে — একটি মান দেয়, আবার i-কেও বদলায়। এই দ্বিতীয় কাজটিকে বলে side effect. এখন i = i++; লাইনে একই i-কে দুজন বদলাতে চাইছে: ++ বলছে “i বাড়াও”, = বলছে “i-তে পুরোনো মানটি রাখো।” কে আগে, কে পরে?

C-র উত্তর হলো — কোনো নিয়ম নেই। C কোডে কিছু নির্দিষ্ট বিন্দু ঠিক করে দেয়, যেখানে পৌঁছানোর আগে আগের সব পরিবর্তন শেষ হয়ে যাওয়ার নিশ্চয়তা থাকে — যেমন প্রতিটি পূর্ণ statement-এর শেষের ;, &&, || আর কমা অপারেটর। এদের বলে sequence point (C11 থেকে একই ধারণাকে “sequenced before” নামে লেখা হয়)। দুটি sequence point-এর মাঝে একই ভ্যারিয়েবল দুবার বদলালে, বা একবার বদলে অন্য জায়গায় আলাদাভাবে পড়লে, ফল undefined behavior. i = i++, i++ + i++, a[i] = i++ — সব এই দলে।

নিচের কোডটি চালিয়ে দেখুন — ভাগ, ভাগশেষ, ঘড়ির হিসাব আর ++-এর আগে-পরে, সব এক জায়গায়:

#include <stdio.h>

int main(void) {
    int biscuits = 17, kids = 5;
    printf("each gets %d, left over %d\n", biscuits / kids, biscuits % kids);
    printf("-7 / 2 = %d, -7 %% 2 = %d\n", -7 / 2, -7 % 2);
    printf("10 o'clock + 5 hours = %d o'clock\n", (10 + 5) % 12);
    printf("last digit of 2024 = %d\n", 2024 % 10);

    int a = 5;
    int b = a++;   /* b gets the OLD value, then a becomes 6 */
    int c = ++a;   /* a becomes 7 first, then c gets 7       */
    printf("a = %d, b = %d, c = %d\n", a, b, c);
    return 0;
}

৪ · তুলনা আর যুক্তি — ==, &&, ||, !

প্রোগ্রাম সিদ্ধান্ত নেয় প্রশ্ন করে: নম্বর ৮০-র বেশি? ব্যালান্স যথেষ্ট? পাসওয়ার্ড মিলেছে? এই প্রশ্নগুলো করে relational operator:

C-তে আলাদা কোনো “সত্য” বা “মিথ্যা” জিনিস নেই (পরে bool এসেছে, কিন্তু ভেতরে সেটিও সংখ্যা)। তুলনার ফল একটি int — সত্য হলে ১, মিথ্যা হলে ০। আর শর্ত পরীক্ষার সময় নিয়ম আরও উদার: ০ মানে মিথ্যা, শূন্য ছাড়া যেকোনো মান সত্য।

শর্ত জোড়া: এবং, অথবা, না

একাধিক প্রশ্ন জুড়তে লাগে logical operator. মেট্রো রেলের গেট খোলে যখন কার্ড বৈধ এবং ব্যালান্স যথেষ্ট — এটি &&. স্কলারশিপ পাওয়া যায় GPA ৫ অথবা বোর্ডে মেধাতালিকায় থাকলে — এটি ||. আর ! উল্টে দেয়: !0 = ১, !7 = ০। নিচের truth table সব সম্ভাবনা দেখায়:

Short-circuit: অলসতাই নিরাপত্তা

টেবিলটি খেয়াল করুন। &&-এ A যদি ০ হয়, B যা-ই হোক ফল ০। আর ||-এ A যদি ১ হয়, ফল ১। C এই সুযোগটি নেয়: বাঁ পাশ দেখেই উত্তর নিশ্চিত হলে ডান পাশ হিসাবই করে না। একে বলে short-circuit evaluation. এটি শুধু সময় বাঁচানোর কৌশল নয় — C-র নিয়মে এটি নিশ্চিত, তাই এর ওপর ভরসা করে পাহারা বসানো যায়।

ধরুন একটি কোচিং সেন্টারের সফটওয়্যার জানতে চায় — গড় নম্বর ৫০-এর বেশি কি না। গড় মানে মোট নম্বর ভাগ ছাত্রসংখ্যা। কিন্তু নতুন ব্যাচে ছাত্রসংখ্যা ০ হলে? নিচে দুটি ক্ষেত্র ধাপে ধাপে দেখুন:

1/* case A: n = 0, total = 0   */2/* case B: n = 4, total = 240 */3if (n != 0 && total / n > 50)4    printf("high average\n");5else6    printf("no data or low\n");

এই কৌশল সব জায়গায় চলে। ভবিষ্যতে pointer শিখলে দেখবেন, p != NULL && p->age > 18 — আগে নিশ্চিত হওয়া যে ঠিকানাটি বৈধ, তারপর সেখানে হাত দেওয়া। ||-এর ক্ষেত্রেও একই চিন্তা উল্টোভাবে: is_admin || has_permission(file) — অ্যাডমিন হলে দ্বিতীয় যাচাইয়ের দরকারই পড়ে না।

৫ · বিটের ভাষায় কথা — & | ^ ~

পর্ব ০৫-এ দেখেছেন, কম্পিউটারে প্রতিটি সংখ্যা আসলে কয়েকটি bit-এর সারি। এতক্ষণের অপারেটরগুলো পুরো সংখ্যাকে একটি মান হিসেবে দেখে। Bitwise operator দেখে ভেতরের প্রতিটি বিটকে আলাদা করে — একই ঘরের বিট জোড়ায় জোড়ায় মিলিয়ে।

সবচেয়ে ছোট উদাহরণ: বিজোড় কি না, এক বিটে

বাইনারিতে প্রতিটি বিজোড় সংখ্যার একেবারে ডানের বিটটি 1, জোড় সংখ্যার 0. তাই n & 1 শুধু শেষ বিটটি রেখে বাকি সব মুছে দেয় — ফল ১ হলে বিজোড়, ০ হলে জোড়। ১৩ = 1101, তাই 13 & 1 = ১। মজার ব্যাপার, ঋণাত্মক সংখ্যাতেও (two's complement-এ) এটি ঠিক কাজ করে, যেখানে n % 2 == 1 ভুল করে।

বিট ফ্ল্যাগ: একটি সংখ্যায় অনেকগুলো হ্যাঁ/না

বিটের সবচেয়ে বড় ব্যবহার bit flag. Linux-এ প্রতিটি ফাইলের তিন রকম অনুমতি থাকে — পড়া (read), লেখা (write), চালানো (execute). প্রতিটি একটি বিট: r = 100 = ৪, w = 010 = ২, x = 001 = ১। এই একেকটি বিট-বাছাই করা সংখ্যাকে বলে bit mask. তিনটি জুড়ে দিলেই একটি অঙ্ক — আর তিন দলের (মালিক, গ্রুপ, বাকি সবাই) জন্য তিনটি অঙ্ক। এটাই বিখ্যাত chmod 755-এর রহস্য। ধাপে ধাপে দেখুন:

           r w x
READ  = 4  1 0 0
WRITE = 2  0 1 0
EXEC  = 1  0 0 1

  READ    1 0 0
| WRITE   0 1 0
| EXEC    0 0 1
  -------------
  owner   1 1 1   = 7 → rwx

  READ    1 0 0
| EXEC    0 0 1
  -------------
  group   1 0 1   = 5 → r-x

  chmod 755 = owner 7, group 5, others 5

  group   1 0 1
& WRITE   0 1 0
  -------------
          0 0 0   = 0 → লেখার অনুমতি নেই

  group   1 0 1
| WRITE   0 1 0
  -------------
  group   1 1 1   = 7 → rwx

  EXEC    0 0 1
  ~EXEC   1 1 0   ← সব বিট উল্টানো

  group   1 1 1
& ~EXEC   1 1 0
  -------------
  group   1 1 0   = 6 → rw-

একই কৌশল হার্ডওয়্যারে: LED জ্বালানো

একটি microcontroller-এর ভেতরে কিছু বিশেষ মেমরি-ঘর থাকে, যাদের বলে register. কিছু register-এর প্রতিটি বিট সরাসরি চিপের একটি পিনের সাথে যুক্ত — বিট 1 করলে পিনে বিদ্যুৎ যায়, 0 করলে বন্ধ। যেমন Arduino Uno বোর্ডের ছোট LED-টি PORTB নামের register-এর ৫ নম্বর বিটে যুক্ত। তাই:

ঠিক এই কারণে embedded system-এর প্রোগ্রামাররা প্রতিদিন বিটওয়াইজ অপারেটর লেখেন। PORTB = 32 লিখলেও LED জ্বলত, কিন্তু একই সাথে বাকি সাতটি পিন বন্ধ হয়ে যেত — হয়তো পাশের মোটরটিও থেমে যেত! মাস্ক দিয়ে কাজ করলে শুধু নিজের বিটটিতে হাত পড়ে।

এবার নিজে চালিয়ে দেখুন — ফাইলের অনুমতির পুরো হিসাবটি কোডে:

#include <stdio.h>

#define READ  4   /* 100 */
#define WRITE 2   /* 010 */
#define EXEC  1   /* 001 */

int main(void) {
    int owner = READ | WRITE | EXEC;     /* 111 = 7 */
    int group = READ | EXEC;             /* 101 = 5 */
    printf("owner = %d, group = %d\n", owner, group);
    if (group & WRITE) printf("group can write\n");
    else               printf("group cannot write\n");
    group |= WRITE;                      /* turn w on  */
    group &= ~EXEC;                      /* turn x off */
    printf("group now = %d\n", group);   /* 110 = 6 */
    printf("13 & 1 = %d, 5 << 3 = %d, -7 >> 1 = %d\n", 13 & 1, 5 << 3, -7 >> 1);
    return 0;
}

৬ · শিফট — ২ দিয়ে গুণ-ভাগের শর্টকাট, আর তার সীমা

Bit shift সব বিটকে একসাথে বাঁয়ে বা ডানে সরিয়ে দেয়। দশমিকে একটি সংখ্যার ডানে একটি শূন্য বসালে মান ১০ গুণ হয় (৫ → ৫০)। বাইনারিতে একই কাজ করলে মান ২ গুণ হয়:

  5        = 0000 0101
  5 << 1   = 0000 1010   = 10   (x 2)
  5 << 3   = 0010 1000   = 40   (x 8)
  40 >> 2  = 0000 1010   = 10   (/ 4)
  1 << 5   = 0010 0000   = 32   (only bit 5 is on)

অর্থাৎ x << k মানে x × ২^k, আর ধনাত্মক x-এর জন্য x >> k মানে x ÷ ২^k (দশমিক বাদ দিয়ে)। আর 1 << k হলো “শুধু k নম্বর বিট চালু” এমন মাস্ক বানানোর সবচেয়ে পরিষ্কার উপায় — LED-এর উদাহরণে যা দেখলেন।

যেখানে শর্টকাট ভেঙে পড়ে

৭ · কে আগে — precedence ও associativity

স্কুলে শিখেছেন BODMAS — আগে বন্ধনী, তারপর ভাগ-গুণ, শেষে যোগ-বিয়োগ। C-রও এমন একটি নিয়ম আছে, তবে অনেক বড়, কারণ অপারেটর অনেক বেশি। কোন অপারেটর আগে কাজ করবে, তার নাম precedence. আর একই স্তরের দুটি অপারেটর পাশাপাশি থাকলে কোন দিক থেকে জোড়া বাঁধা হবে, তার নাম associativity.

Compiler আসলে expression-টিকে একটি গাছের মতো সাজায় — উঁচু অগ্রাধিকারের অপারেটর থাকে নিচের ডালে, তাই তারা আগে হিসাব হয়। 2 + 3 * 4 - 8 / 2 কীভাবে ১০ হয়, ধাপে ধাপে দেখুন:

  2  +  3  *  4  -  8  /  2

  *  /   উঁচু স্তর  → আগে জোড়া বাঁধে
  +  -   নিচু স্তর  → পরে, বাঁ থেকে ডানে

            [-]
           /   \
        [+]     [/]
       /   \    /  \
      2   [*]  8    2
          /  \
         3    4

            [-]
           /   \
        [+]     [/]
       /   \    /  \
      2    12  8    2

            [-]
           /   \
        [+]     4
       /   \
      2    12

            [-]
           /   \
         14     4

            10

  পুরো expression-এর মান = 10

পুরো precedence তালিকা মুখস্থ করার দরকার নেই। নিচের সংক্ষিপ্ত তালিকাটি (উপর থেকে নিচে, উঁচু থেকে নিচু অগ্রাধিকার) চিনে রাখুন, বিশেষ করে লাল দাগের জায়গাগুলো:

Associativity-র দুটি উদাহরণ: 20 - 5 - 3 = (20 - 5) - 3 = ১২ (বাঁ থেকে ডানে; উল্টো করলে হতো ১৮)। আর a = b = 5 = a = (b = 5) (ডান থেকে বাঁয়ে) — তাই দুটিতেই ৫ বসে। আবার 2 * 3 % 4: * আর % একই স্তরের, বাঁ থেকে ডানে, তাই (2 * 3) % 4 = ২।

৮ · ক্লাসিক ফাঁদ — যেখানে অভিজ্ঞরাও ভুল করেন

উপরের তালিকায় একটি অদ্ভুত ব্যাপার চোখে পড়েছে? বিটের & আছে ==-এর নিচে. অর্থাৎ তুলনা আগে হয়, বিটের AND পরে। এর ফল কী হতে পারে, একটি বাস্তব বাগ দিয়ে দেখি। কেউ লিখতে চাইলেন — “x জোড় হলে কিছু করো”:

int x = 4;
if (x & 1 == 0) {
    printf("even\n");
}
/* প্রোগ্রামারের মনে: (x & 1) == 0 */

     x & (1 == 0)

  == আগে জোড়া বাঁধল 1 আর 0-এর সাথে

     x & 0

  1 == 0 মিথ্যা → মান 0

     0100   (x = 4)
   & 0000
   ------
     0000   → শর্ত মিথ্যা, "even" কখনো ছাপা হয় না

  সমাধান: if ((x & 1) == 0)

এমন আরও কয়েকটি ফাঁদ, যেগুলো বারবার দেখা যায় — নতুনদের কোডে, পুরোনো প্রজেক্টে, এবং AI-এর লেখা কোডেও:

পেশাদার কোডে নিয়মটি আরও কড়া: যেখানেই বিটের অপারেটর আর তুলনা একসাথে, বা && আর || একসাথে, সেখানে বন্ধনী দিন — নিজের জন্য যতটা না, ছয় মাস পরে কোডটি যিনি পড়বেন তাঁর জন্য।

৯ · AI-এর যুগে অপারেটর যাচাই

AI খুব সাবলীলভাবে expression লেখে — আর ঠিক সেজন্যই এর ভুলগুলো চোখে পড়ে না। লাইনটি দেখতে নিখুঁত, compile হয়, সাধারণ ইনপুটে ঠিক উত্তরও দেয়। সমস্যা ধরা পড়ে শূন্য, ঋণাত্মক বা বড় সংখ্যায়। অপারেটর নিয়ে AI-এর সাধারণ ভুলগুলো:

AI-এর দেওয়া expression হাতে পেলে — যাচাইয়ের চেকলিস্ট

• -Wall -Wextra দিয়ে compile করেছি — -Wparentheses বা -Wsequence-point ধরনের কোনো warning নেই
• বিটের অপারেটর (& | ^) আর তুলনা একসাথে থাকলে প্রতিটিতে বন্ধনী আছে
• কোনো statement-এ একই ভ্যারিয়েবল দুবার বদলানো হয়নি
• যেখানে ভাগ আছে, সেখানে ভাজক শূন্য হতে পারে কি না দেখেছি, আর পাহারাটি &&-এর বাঁ পাশে আছে
• বিট নিয়ে কাজ হলে টাইপটি unsigned; শিফটের পরিমাণ ০ থেকে বিট-সংখ্যার কম
• ০, ঋণাত্মক সংখ্যা আর খুব বড় সংখ্যা দিয়ে চালিয়ে হাতে হিসাব মিলিয়েছি