Sizeof আর limits.h: আন্দাজ না করে মেশিনকে জিজ্ঞেস করা

Kenji-র program এক বছর ধরে ওর laptop-এ চলে। তারপর সেটা একটা card reader-র ছোট chip-এ তোলা হয়, আর 32,767-র উপরের প্রতিটা সংখ্যা ভুল বেরোয়।

ও bug লেখেনি। ও একটা মাপ মাথায় লিখে রেখেছিল, আর সেটা নিয়ে এমন একটা মেশিনে গিয়েছিল যে একমত না। এই পুরো lesson একটাই অভ্যাস: জিজ্ঞেস করো, আন্দাজ করো না।

sizeof: যে operator byte-এ উত্তর দেয়

sizeof দেখতে function-র মতো, আর ওটা function না। ওটা ভাষার ভেতরে বসানো একটা operator, আর program চালু হওয়ার আগেই compiler তার উত্তর বের করে ফেলে।

sizeof(int)         একটা TYPE-র জন্য bracket লাগবেই
sizeof marks        একটা EXPRESSION-র জন্য লাগে না
sizeof(marks)       এটাও ঠিক, আর বেশির ভাগ মানুষ এটাই লেখে

sizeof marks + 1    মানে (sizeof marks) + 1, যেটা 5
sizeof (marks + 1)  মানে expression-টার মাপ, যেটা 4

তাই type-র জন্য bracket বাধ্যতামূলক আর variable-র জন্য ঐচ্ছিক, আর ওই card-র শেষ দুই লাইন এমন একটা ফাঁদ যেটা দুইবার পড়া দরকার।

size_t, আর তার সঙ্গের %zu

sizeof একটা int ফেরত দেয় না। ও ফেরত দেয় একটা size_t, একটা unsigned type, যেটা মেশিনের রাখতে পারা সবচেয়ে বড় জিনিসের মাপ ধরার মতো চওড়া।

Playground-এ আর যেকোনো 64 bit মেশিনে ওটা 8 byte, আর ছোট একটা chip-এ 2 byte। এটাই ওর মানে: ওকে মেশিন ঠিক করে, কারো বেছে নেওয়া কোনো সংখ্যা না।

Unsigned বলেই size_t কখনো ঋণাত্মক হতে পারে না, আর শূন্য পেরিয়ে বিয়োগ করলে lesson 2-র বর্ণনামতোই ঘুরে যায়।

তাই ওটা %zu দিয়ে ছাপো, আর অঙ্কের জন্য সাধারণ int চাইলে cast-টা নিজে লেখো আর বুঝে লেখো।

limits.h আর float.h: ছাপা, টুকে রাখা না

দুইটা header-এ প্রতিটা সীমার মান থাকে, তুমি যে মেশিনে আছ তার জন্য আগে থেকেই ঠিক করা।

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void)
{
    printf("bits in a byte : %d\n", CHAR_BIT);
    printf("int range      : %d to %d\n", INT_MIN, INT_MAX);
    printf("long long top  : %lld\n", LLONG_MAX);
    printf("float digits   : %d\n", FLT_DIG);
    printf("double digits  : %d\n", DBL_DIG);
    printf("double largest : %e\n", DBL_MAX);
    return 0;
}

bits in a byte : 8
int range      : -2147483648 to 2147483647
long long top  : 9223372036854775807
float digits   : 6
double digits  : 15
double largest : 1.797693e+308

FLT_DIG হলো 6 আর DBL_DIG হলো 15। Lesson 3 বলেছিল "প্রায় 7" আর "প্রায় 15 বা 16"; এগুলোই সেই সংখ্যা, যেগুলোর পিছনে মেশিন সত্যিই দাঁড়াবে।

তাই তুমি যে সীমা ছেপেছ সেটা আজকের মেশিন নিয়ে একটা সত্য। মুখস্থ থেকে লেখা সীমা একটা আশা।

long-কেই সন্দেহ করতে হবে

এখানে এমন একটা তথ্য, যেটা তুমি নিজে যাচাই করতে পারো, আর এই পুরো lesson থাকার কারণও এটাই।

Playground-এ, যেটা 64 bit Linux চালায়, sizeof(long) হলো 8। একই processor আর একই compiler-র একটা Windows মেশিনে ওটা 4।

একই code, একই chip, একই GCC। দুইটা উত্তর। কোনোটাতেই কিছু ভুল নেই: standard কেবল কথা দেয় long প্রায় দুইশো কোটির এদিক-ওদিক পর্যন্ত পৌঁছাবে, আর দুইটা মেশিনই সেই কথা রাখে।

এই module-র বাকি প্রতিটা মাপ দুই জায়গাতেই মেলে: char 1, short 2, int 4, long long 8, float 4, double 8।

তাই এই track long long লেখে আর কখনো long না, আর নিচের অনুশীলনটা তোমাকে এমন একটা মাপের তালিকা ছাপতে বলে যেখানে long ইচ্ছে করেই নেই।

stdint.h: মাপটা সব জায়গায় এক হতে হলে

মাঝে মাঝে "অন্তত 4 byte" যথেষ্ট না। একটা network packet, একটা file format আর একটা hash-র এমন একটা মান লাগে যেটা প্রতিটা মেশিনে, চিরকাল, ঠিক 32 bit চওড়া।

<stdint.h> তোমাকে সেই type-গুলো দেয়, আর তাদের নামেই চওড়াটা লেখা থাকে।

এগুলো নতুন type না। এগুলো সাধারণ type-গুলোরই অন্য নাম, প্রতিটা মেশিনে এমনভাবে বাছা যাতে চওড়াটা ঠিক থাকে। Playground-এ int32_t হলো int।

এগুলো ছাপতে একটু সাবধানতা লাগে, কারণ নিচের আসল type মেশিনভেদে আলাদা। এই module-র ভেতরে একটা fixed-width মান long long আর %lld দিয়ে পড়ো আর ছাপো, যেটা সবগুলোর জন্যই যথেষ্ট চওড়া।

তাই সাধারণ গোনার জন্য সাধারণ int নাও, আর bit-র সংখ্যাটা যখন নকশারই অংশ তখন একটা fixed-width type নাও।

#include <stdio.h>

int main(void)
{
    int marks = 90;

    printf("sizeof(int)        : %zu\n", sizeof(int));
    printf("sizeof marks       : %zu\n", sizeof marks);
    printf("sizeof marks + 1   : %zu\n", sizeof marks + 1);
    printf("sizeof (marks + 1) : %zu\n", sizeof (marks + 1));
    return 0;
}

sizeof(int)        : 4
sizeof marks       : 4
sizeof marks + 1   : 5
sizeof (marks + 1) : 4

#include <stdio.h>

int main(void)
{
    printf("char      : %zu\n", sizeof(char));
    printf("short     : %zu\n", sizeof(short));
    printf("int       : %zu\n", sizeof(int));
    printf("long long : %zu\n", sizeof(long long));
    printf("float     : %zu\n", sizeof(float));
    printf("double    : %zu\n", sizeof(double));
    printf("size_t    : %zu\n", sizeof(size_t));
    printf("long      : ask your own machine\n");
    return 0;
}

char      : 1
short     : 2
int       : 4
long long : 8
float     : 4
double    : 8
size_t    : 8
long      : ask your own machine

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

int main(void)
{
    uint8_t  version = 4;
    uint16_t port = 443;
    int64_t  timestamp = 1758240000;

    printf("version   : %lld in %zu byte\n", (long long)version, sizeof version);
    printf("port      : %lld in %zu bytes\n", (long long)port, sizeof port);
    printf("timestamp : %lld in %zu bytes\n", (long long)timestamp, sizeof timestamp);
    return 0;
}

version   : 4 in 1 byte
port      : 443 in 2 bytes
timestamp : 1758240000 in 8 bytes

printf("%d\n", sizeof(int));

#include <stdio.h>

int main(void)
{
    printf("%d\n", INT_MAX);
    return 0;
}

int marks = 90;
printf("%zu\n", sizeof marks + 1);

long total_bytes = 8;      /* "a long is 8 bytes" */

#include <stdio.h>
#include <limits.h>

int main(void)
{
    printf("bits: %zu\n", sizeof(int) * 8);
    printf("bits: %zu\n", sizeof(int) * CHAR_BIT);
    return 0;
}

#include <stdio.h>

int main(void)
{
    printf("char: %zu\n", sizeof(char));

    /* Five more lines, same shape. */

    return 0;
}

#include <stdio.h>

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

    /* Multiply by sizeof(double), print with %lld. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    long long lo = 0;
    long long hi = 0;
    scanf("%lld %lld", &lo, &hi);

    /* Lesson 4: a comparison is a 1 or a 0, and two of them multiplied is "both". */

    return 0;
}

পরেরটা Problems lesson: এই module-র সবকিছুর উপরে দশটা judge করা সমস্যা, লুকানো test-র বিরুদ্ধে।