Relational আর logical operator, আর short circuit

Zara জানতে চায় একটা মার্ক 1 আর 10-র মাঝে পড়ে কি না। ও লেখে 1 < mark < 10, কাগজে যেভাবে সীমাটা লেখা হয়।

ওটা compile হয়। Playground একটা কথাও বলে না। আর 42 মার্কের জন্য, 900 মার্কের জন্য, ও যত সংখ্যা দেয় সবটার জন্যই উত্তর আসে 1।

লাইনটা ভাঙা না। ওটা পুরোপুরি সাধারণ একটা expression, যেটার মানে ও যা পড়েছিল তার চেয়ে আলাদা।

তুলনা একটা int, যার মান 1 বা 0

Module 2-র lesson 4 কথাটা একবার বলেছিল। এই lesson ওটার উপরই দাঁড়ানো, তাই ছয়টা operator সহ আবার বলি।

a <  b     a কি b-র চেয়ে ছোট
a <= b     a কি b-র চেয়ে ছোট বা সমান
a >  b     a কি b-র চেয়ে বড়
a >= b     a কি b-র চেয়ে বড় বা সমান
a == b     a কি b-র সমান            সব সময় দুইটা সমান-চিহ্ন
a != b     a কি b-র সমান নয়

#include <stdio.h>

int main(void)
{
    int mark = 42;

    printf("mark < 50   %d\n", mark < 50);
    printf("mark >= 40  %d\n", mark >= 40);
    printf("mark == 42  %d\n", mark == 42);
    printf("mark != 42  %d\n", mark != 42);
    return 0;
}

mark < 50   1
mark >= 40  1
mark == 42  1
mark != 42  0

এখানে কেউ কোনো সিদ্ধান্ত নিচ্ছে না। চারটা প্রশ্ন করা হলো আর চারটা সংখ্যা ফিরে এলো।

1 < mark < 10 কেন compile হয় আর মিথ্যা বলে

Relational operator বাঁ দিক থেকে দল বাঁধে। তাই C Zara-র লাইনটা পড়ে (1 < mark) < 10 হিসেবে।

বন্ধনীর ভিতরের অংশটা একটা তুলনা, তাই ওটার মান 1 বা 0। তারপর C জিজ্ঞেস করে ওই 1 বা 0 কি 10-র চেয়ে ছোট। সব সময়ই ছোট।

#include <stdio.h>

int main(void)
{
    int mark = 900;

    printf("1 < mark        %d\n", 1 < mark);
    printf("that, < 10      %d\n", (1 < mark) < 10);
    printf("written chained %d\n", 1 < mark < 10);
    return 0;
}

1 < mark        1
that, < 10      1
written chained 1

শেষ দুই লাইন একই expression, দুইবার লেখা। বন্ধনী শুধু পড়ার ধরনটা চোখে আঙুল দিয়ে দেখায়।

Playground-র command line-এ এটা পুরো নীরব, কারণ পরীক্ষাটা -Wall-র পিছনে থাকে। স্থানীয় একটা gcc -Wall দুইটা warning দেয়: comparisons like 'X<=Y<=Z' do not have their mathematical meaning আর comparison of constant '10' with boolean expression is always true।

তাই একটা সীমা মেলাতে দুইটা আলাদা তুলনা লাগে, আর পরের অংশের operator ওদের জোড়া দেয়।

&& আর ||, আর যে truth table একটা program ছেপে দিতে পারে

&& মানে "আর": দুই পাশই সত্য হলে 1। || মানে "অথবা": অন্তত এক পাশ সত্য হলে 1।

এখানে "সত্য" মানে "শূন্য না", Module 2-র নিয়ম। ফলটা আবারও সাধারণ একটা int, যার মান 1 বা 0।

#include <stdio.h>

int main(void)
{
    printf("p q   p&&q  p||q  !p\n");
    printf("0 0    %d     %d    %d\n", 0 && 0, 0 || 0, !0);
    printf("0 1    %d     %d    %d\n", 0 && 1, 0 || 1, !0);
    printf("1 0    %d     %d    %d\n", 1 && 0, 1 || 0, !1);
    printf("1 1    %d     %d    %d\n", 1 && 1, 1 || 1, !1);
    return 0;
}

p q   p&&q  p||q  !p
0 0    0     0    1
0 1    0     1    1
1 0    0     1    0
1 1    1     1    0

Zara-র সীমা-পরীক্ষাটা এখন নিজেই লেখা হয়ে যায়: mark > 1 && mark < 10। দুইটা প্রশ্ন, একটা জোড়া দেওয়ার শব্দ।

তাই truth table মুখস্থ করার জিনিস না। ওটা চার লাইন, যা একটা program দশ সেকেন্ডে তোমাকে ছেপে দেবে।

Short circuit: ডান পাশটা হয়তো চলবেই না

C ওই table-র চেয়ে বেশি কথা দেয়। ও একটা ক্রম কথা দেয়, আর আগেভাগে থেমে যাওয়ার সুযোগ দেয়।

a && b-তে C আগে a হিসাব করে। a যদি 0 হয়, উত্তর তো 0 হয়েই গেছে, তাই b আর হিসাবই হয় না।

a || b-তে C আগে a হিসাব করে। a শূন্য না হলে উত্তর তো 1 হয়েই গেছে, তাই b বাদ পড়ে যায়।

তুমি নিজের চোখে দেখতে পারো। printf কতগুলো অক্ষর ছেপেছে সেই সংখ্যাটা ফেরত দেয়, তাই একটা printf ডান পাশের মান হিসেবে চলে।

#include <stdio.h>

int main(void)
{
    int stock = 0;

    printf("start\n");
    int a = stock && printf("  the right side of && ran\n");
    int b = 1 || printf("  the right side of || ran\n");
    printf("a %d, b %d\n", a, b);
    return 0;
}

start
a 0, b 1

কোনো বার্তাই এলো না। stock ছিল 0, তাই && থেমে গেল; 1 তো আগেই সত্য, তাই || থেমে গেল।

তাই বিপজ্জনক কাজ আটকানোর উপায় হলো short circuit: পরীক্ষাটা &&-র বাঁ পাশে রাখো, তাহলে ডান পাশের বিপজ্জনক অংশটা কেবল পরীক্ষা পাশ করলেই চলতে পারে।

! সংখ্যাকে উত্তর বানায়, আর !! উত্তরটা সমান করে

! মানে "না"। শূন্য না এমন যেকোনো মানের জন্য ও দেয় 0, আর শূন্যের জন্য দেয় 1।

দুইবার লাগালে এমন একটা মান পাবে যেটা 1 বা 0, আর কিছুই না। !!7 হলো 1, !!0 হলো 0।

#include <stdio.h>

int main(void)
{
    int credits = 7;

    printf("credits      %d\n", credits);
    printf("!credits     %d\n", !credits);
    printf("!!credits    %d\n", !!credits);
    return 0;
}

credits      7
!credits     0
!!credits    1

!! জোড়াটা "এটাকে ঠিক 1 বা 0-তে নামাও" বোঝানোর চেনা একটা idiom। ওটা আলাদা কোনো operator না; ওটা !-কে দুইবার লেখা।

তাই "credit আছে কি না" আর "কত credit আছে" আলাদা দুইটা মান হয়ে যায়, আর তার একটাকেই কেবল 1-র সাথে মেলানো নিরাপদ।

Ternary: এক expression, দুইটা সম্ভাব্য মান

এতক্ষণের প্রতিটা operator দুইটা মান নিত। এটা নেয় তিনটা, আর C-তে এমন operator আর একটাও নেই।

condition ? value_if_true : value_if_false

#include <stdio.h>

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

    int larger = (a > b) ? a : b;

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

91

ওই output-টা 91 47 input-র জন্য। Module 5 একই জিনিস if দিয়ে চার লাইনে লিখবে; এখানে ওটা এক লাইন।

Track-র পরামর্শ এক লাইনের: দুই দিকের ফলই যখন একই ধরনের মান, তখন ternary নাও, আর যেই কোনো এক দিক মান বানানোর বদলে কাজ করতে শুরু করে, তখনই if-এ যাও।

#include <stdio.h>

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

    int adult = age >= 18;

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

1

#include <stdio.h>

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

    int in_range = mark >= 1 && mark <= 10;

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

0

#include <stdio.h>

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

    int big = (d != 0) && (n / d > 10);

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

0

int ok = 1 < mark < 10;
printf("%d\n", ok);

int matched = code = 5;
printf("matched %d\n", matched);

int big = (d != 0) & (n / d > 10);

printf("%d\n", 0.1 + 0.2 == 0.3);

#include <stdio.h>

int main(void)
{
    int x = 5;
    int y = 3;

    int t = (x == 5) + (y == 5);

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

#include <stdio.h>

int main(void)
{
    int low = 0;
    int high = 0;
    int x = 0;
    scanf("%d %d %d", &low, &high, &x);

    /* Two comparisons and one &&. Both ends are included. */

    return 0;
}

#include <stdio.h>

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

    /* Three remainders, two comparisons joined by &&, then one ||. */

    return 0;
}

#include <stdio.h>

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

    /* One ternary. Equal values make both branches correct. */

    return 0;
}

#include <stdio.h>

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

    /* Four printf lines, each one expression. No loop, no condition. */

    return 0;
}

এরপর তুমি total = total + x লেখা ছেড়ে ছোট রূপগুলো শিখবে, যার একটার ভিতরে undefined behaviour লুকিয়ে আছে।