Precedence আর associativity: কখন bracket দেবে

Zara দেখছে একটা flag byte-র সবচেয়ে নিচের bit খালি কি না। ও লেখে x & 1 == 0, যেটা পড়তে হুবহু কথাটার মতো।

Playground একটা কথাও না বলে ওটা compile করে। x 4 হলে উত্তর 1 হওয়ার কথা, কিন্তু আসে 0। আর বাকি প্রতিটা মানেও 0 আসে।

Operator-গুলো ঠিক, ক্রমটা ভুল। & কাছে যাওয়ার আগেই == দুই পাশের মান দখল করে নেয়।

Precedence ঠিক করে কে মানটা পাবে

2 + 3 * 4-তে 3 সংখ্যাটা দুই operator-র মাঝে বসে আছে। ওদের একজনই ওকে পেতে পারে।

Precedence হলো সেই তালিকা যেটা ঝগড়াটা মিটিয়ে দেয়। *-র পদ +-র উপরে, তাই 3 যায় গুণের কাছে।

#include <stdio.h>

int main(void)
{
    printf("2 + 3 * 4   = %d\n", 2 + 3 * 4);
    printf("(2 + 3) * 4 = %d\n", (2 + 3) * 4);
    return 0;
}

2 + 3 * 4   = 14
(2 + 3) * 4 = 20

Bracket সবার উপরে। ওটা compiler-কে দেওয়া কোনো ইঙ্গিত না; ওটা বদলে দেয় কোন operator মানটা পাবে।

তাই precedence মানে সময়ের হিসাবে কোনটা আগে চলবে তা না। মানে হলো, কিছু চলার আগেই লাইনটা কীভাবে দল বাঁধবে।

Table, পনেরো সারি, উপরে সবচেয়ে উঁচুটা

C-র table-র যতটুকু এই track শিখিয়েছে বা শেখাবে, ততটুকু এখানে। এখানে দেখে নাও; মুখস্থ কোরো না।

ওই table-র দুইটা জিনিস আরেকবার দেখার মতো, আর দুইটাই এই lesson-র ফাঁদ।

6 আর 7 নম্বর সারি বসে আছে 8 থেকে 10 নম্বরের উপরে। প্রতিটা তুলনা প্রতিটা bitwise operator-র চেয়ে শক্ত করে ধরে।

5 নম্বর সারি বসে আছে 3 আর 4 নম্বরের নিচে। প্রতিটা shift সাধারণ যোগ-বিয়োগের চেয়ে ঢিলে করে ধরে।

Associativity: এক সারি কোন দিকে হেলে

Precedence আলাদা সারির ঝগড়া মেটায়। Associativity এক সারির ভিতরের ঝগড়া মেটায়।

3 থেকে 12 নম্বর সারি বাঁ থেকে ডানে দল বাঁধে। 20 - 8 - 3 মানে (20 - 8) - 3, যেটা 9, 15 না।

2, 13 আর 14 নম্বর সারি ডান থেকে বাঁয়ে বাঁধে। তাই p = q = r = 7 কাজ করে: ডানের assignment-টা আগে হয় আর তার মান বাঁ দিকে বইতে থাকে।

#include <stdio.h>

int main(void)
{
    int a = 20;
    int b = 8;
    int c = 3;

    printf("a - b - c   = %d\n", a - b - c);
    printf("a - (b - c) = %d\n", a - (b - c));

    int p = 0;
    int q = 0;
    int r = 0;
    p = q = r = 7;
    printf("p %d q %d r %d\n", p, q, r);
    return 0;
}

a - b - c   = 9
a - (b - c) = 15
p 7 q 7 r 7

বিয়োগ অন্য দিকে হেললে স্কুলের অঙ্কই ভেঙে যেত, তাই বাঁ থেকে ডানেটাই তুমি আগে থেকে আশা করো।

তাই associativity তখনই গুরুত্ব পায় যখন তুমি একই পদের দুইটা operator পরপর লিখেছ, আর অঙ্কের বেশির ভাগ লাইনই তাই।

যে দুইটা ফাঁদ সত্যিই কামড় দেয়

বাস্তব C-র প্রায় প্রতিটা precedence bug দুইটা গড়নের একটা, আর table আগেই দুইটাই বলে দিয়েছে।

ফাঁদ এক: bitwise operator-র পাশে একটা তুলনা। 6 আর 7 নম্বর সারি 8 নম্বরের উপরে, তাই তুলনাটাই জেতে।

#include <stdio.h>

int main(void)
{
    unsigned int x = 4u;

    printf("x & 1u == 0u   %u\n", x & 1u == 0u);
    printf("(x & 1u) == 0u %u\n", (x & 1u) == 0u);
    return 0;
}

x & 1u == 0u   0
(x & 1u) == 0u 1

প্রথম লাইনটা আসলে x & (1u == 0u), মানে x & 0, মানে পৃথিবীর প্রতিটা x-র জন্য 0।

Playground কিছুই বলে না। স্থানীয় gcc -Wall বলে warning: suggest parentheses around comparison in operand of '&', মানে compiler তোমাকে table-র উত্তরটাই জানাচ্ছে।

ফাঁদ দুই: যোগের পাশে একটা shift। 5 নম্বর সারি 4 নম্বরের নিচে, তাই যোগটা আগে হয়।

#include <stdio.h>

int main(void)
{
    printf("1u << 2 + 1   = %u\n", 1u << 2 + 1);
    printf("(1u << 2) + 1 = %u\n", (1u << 2) + 1);
    return 0;
}

1u << 2 + 1   = 8
(1u << 2) + 1 = 5

প্রথমটা আসলে 1u << 3। দুই উত্তর 8 আর 5, আর তার একটাই শুধু 2-র ঘাত, আর সাধারণত এভাবেই এটা ধরা পড়ে।

তাই দুই ফাঁদের কারণ এক: C তার operator-গুলোকে এমন ক্রমে সাজিয়েছে যেটা কথাগুলো পড়ার ধরনের সাথে মেলে না।

পাঁচটা নিয়ম, আর bracket-র একটা নিয়ম

রোজকার code-এ তোমার table লাগে না। পাঁচটা কথায় তার প্রায় পুরোটাই মেটে।

1  binary-র আগে unary            -a * b   মানে   (-a) * b
2  + --র আগে * / %               a + b * c   মানে   a + (b * c)
3  তুলনা, তারপর &&, তারপর ||     a < b && c < d   -এ bracket লাগে না
4  assignment সবার শেষে, আর ডানে হেলে     p = q = 7
5  bracket সব সময় জেতে

ওই ফাঁক থেকেই track-র style নিয়মটা আসে: এক লাইনে অন্য কিছু থাকলে প্রতিটা bitwise operator আর প্রতিটা shift bracket-এ ঢাকো।

Bracket চালানোর সময় কিছুই খরচ করে না। Compiler হুবহু একই machine code বানায়, তাই ওদের একমাত্র পাঠক মানুষ।

#include <stdio.h>

int main(void)
{
    int n = 0;
    scanf("%d", &n);

    printf("%d\n", 10 - 4 > n);
    printf("%d\n", 10 - (4 > n));
    return 0;
}

1
9

#include <stdio.h>

int main(void)
{
    unsigned int x = 0;
    scanf("%u", &x);

    printf("no brackets %u\n", x & 1u == 0u);
    printf("bracketed   %u\n", (x & 1u) == 0u);
    return 0;
}

no brackets 0
bracketed   1

#include <stdio.h>

int main(void)
{
    double u = 0.0;
    double t = 0.0;
    double a = 0.0;
    scanf("%lf %lf %lf", &u, &t, &a);

    double distance = u * t + 0.5 * a * t * t;

    printf("%.2f\n", distance);
    return 0;
}

80.10

unsigned int x = 4u;
printf("%u\n", x & 1u == 0u);

printf("%u\n", 1u << 2 + 1);

printf("%d\n", 1 | 2 ^ 3 & 4);

int r = f() + g() * h();

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;

    a = 1, b = 2;

    printf("a %d b %d\n", a, b);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    scanf("%d %d %d", &a, &b, &c);

    /* Type the five expressions exactly as written. Add no brackets. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    unsigned int x = 0;
    unsigned int n = 0;
    scanf("%u %u", &x, &n);

    /* Each line needs exactly one pair of brackets, around the bitwise part. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    double mass = 0.0;
    double speed = 0.0;
    double time = 0.0;
    scanf("%lf %lf %lf", &mass, &speed, &time);

    /* Rule 2 does the first line. The second needs one pair of brackets. */

    return 0;
}

এরপর জানবে, একটা operator-র দুই পাশের type একদমই আলাদা হলে কী ঘটে।