auto আর range-for: কম লেখা, একই মানে

পুরনো একটা contest solution-এ Zara এই লাইনটা পেয়েছে: for (std::vector<std::pair<std::string, int>>::iterator it = v.begin(); it != v.end(); ++it)। কাজ বলতে শুধু একটা list-এর প্রতিটা item-এ একবার করে যাওয়া, অথচ শুধু type-টাই ওর বেশিরভাগ program-এর চেয়ে লম্বা। আজকের C++ একই loop লেখে for (auto& p : v) দিয়ে। এত ছোট হলো কীভাবে, তার দুইটা টুকরো এই lesson বোঝাবে: auto আর range-for।

auto: type লেখে compiler

একটা variable যখন একটা মান নিয়ে শুরু হয়, মানটাই বলে দেয় তার type কী। 5 একটা int, 2.5 একটা double, 'z' একটা char। auto keyword compiler-কে বলে, type-টা মান থেকেই নিয়ে নাও, যাতে তোমাকে দুইবার লিখতে না হয়।

auto name = initial_value;

#include <iostream>
#include <string>

int main()
{
    auto count = 3;
    auto price = 2.5;
    auto grade = 'A';
    auto name = std::string("Zara");

    std::cout << name << " bought " << count << " pens at " << price << '\n';
    std::cout << "grade " << grade << ", total " << count * price << '\n';
    return 0;
}

Zara bought 3 pens at 2.5
grade A, total 7.5

count হলো int, price একটা double, grade একটা char, আর name একটা std::string। Type ঠিক হয় program compile হওয়ার সময়, আর তারপর আর কখনো বদলায় না। তাই auto এমন কোনো বাক্স না যেটায় "যা খুশি" রাখা যায়: এটা সেই একই নির্দিষ্ট type, যেটা তুমি নিজেই লিখতে, শুধু তোমার হয়ে বসিয়ে দেওয়া।

Compiler কোন type বেছেছে, তাকে দিয়েই বলানো

Maria কথায় ভোলে না, প্রমাণ চায়। এর জন্য একটা পুরনো কৌশল আছে: variable-টা দিয়ে compiler-কে একটা অসম্ভব কাজ করতে বলো, তারপর error-টা পড়ো। বার্তায় type-এর নাম আসতেই হবে।

এখানে অসম্ভব কাজটা হলো একটা মানকে একটা খালি struct-এ বদলে ফেলা, মানে কোনো field ছাড়া struct, যেটা C++ মেনে নেয়। GCC 12 প্রতিটা লাইন ফিরিয়ে দেয়, আর প্রতিটা না-তেই বলে দেয় তাকে কী দেওয়া হয়েছিল।

struct Probe {};

int main()
{
    auto a = 5;
    auto b = 2.5;
    auto c = 'z';
    auto d = 3000000000;
    auto e = "hi";
    auto f = 7 / 2;

    Probe p1 = a;
    Probe p2 = b;
    Probe p3 = c;
    Probe p4 = d;
    Probe p5 = e;
    Probe p6 = f;
    return 0;
}

Playground-এর command line-এ GCC 12 ছয়টা error দেখায়। প্রতিটা লাইনের যে অংশটা কাজের, সেটা নিচে।

দুইটা সারি আরেকবার দেখার মতো। 3000000000 একটা int-এ আঁটে না, তাই literal-টা নিজেই একটা long; Playground-এর Linux-এ একটা long 8 byte। আর "hi" এখনো তোমার চেনা সেই C string, একটা const char*। এজন্যই প্রথম program লিখেছিল std::string("Zara")।

মানে auto হুবহু মানের type-টাই নেয়, তুমি কী বোঝাতে চেয়েছিলে তা নিয়ে কোনো আন্দাজ ছাড়া, আর ইচ্ছে করে একটা error ঘটালে compiler সেটা দেখিয়েও দেয়।

auto কী বাদ দেয়, আর কীভাবে ধরে রাখবে

auto নেয় মানের type, যে variable থেকে মানটা এসেছে তার সবকিছু না। দুইটা জিনিস পেছনে পড়ে থাকে: const, আর reference হওয়াটা। ফল সবসময় নতুন একটা, লেখার মতো copy।

#include <iostream>

int main()
{
    const int limit = 10;
    auto a = limit;
    a = 11;

    int x = 5;
    int& r = x;
    auto b = r;
    b = 99;
    std::cout << "a = " << a << ", x after b = 99: " << x << '\n';

    auto& c = r;
    c = 42;
    std::cout << "x after c = 42: " << x << '\n';
    return 0;
}

a = 11, x after b = 99: 5
x after c = 42: 42

a একটা সাধারণ int, তাই limit const হলেও a = 11 চলে। b হলো r-এর পেছনের মানটার একটা copy, তাই এটা বদলালে x 5-ই থাকে। Reference ধরে রেখেছে শুধু auto&, আর তখনই c = 42 গিয়ে পৌঁছেছে x-এ।

মানে সাধারণ auto সবসময় copy বানায়। দ্বিতীয় নাম চাইলে & যোগ করো, আর শুধু পড়ার দ্বিতীয় নাম চাইলে const auto&।

Range-for: প্রতিটা বাক্স, ক্রম ধরে

C-তে array ঘোরা মানে একটা index, একটা সীমা আর একটা বাড়ানো, Bob-এর off-by-one ভুলের তিনটা সুযোগ। Range-for শুধু বলে "এর প্রতিটা element-এর জন্য"। শুরু করে প্রথম বাক্স থেকে, শেষ করে শেষটার পরে, আর কোনো index-ই লাগে না।

for (declaration : range) {
    body
}

#include <iostream>

int main()
{
    int marks[5] = {70, 85, 62, 91, 48};
    int total = 0;

    for (int m : marks) {
        total += m;
    }
    std::cout << "total " << total << ", average " << total / 5.0 << '\n';
    return 0;
}

total 356, average 71.2

একটা কথা C জানা পাঠকের জানতেই হবে। C array-র ওপর range-for array-র প্রতিটা বাক্সে যায়: capacity ধরে, count ধরে না। 5টা নম্বর রাখা একটা int a[100] পায় 100টা পাক, যার 95টাই অব্যবহৃত বাক্সে। তাই C array-তে এটা ব্যবহার করো শুধু তখন, যখন প্রতিটা বাক্সেই data আছে, ওপরের মতো। Module 2-এর vector নিজের count জানে, এজন্যই STL lesson-গুলো সব জায়গায় range-for ব্যবহার করে।

মানে range-for প্রতিটা element-এ একবার যায়, প্রথম থেকে শেষ পর্যন্ত, আর ভুল করার মতো কোনো index থাকেই না।

তিনটা রূপ: copy, বদলানো, পড়া

Colon-এর আগের declaration ঠিক করে প্রতিটা পাকে কী আসবে। এটা আবার সেই lesson 03, আর এই ছবিতে তিনটা রূপই আছে।

তিনটা রূপ এক program-এ, প্রতিটাই একই marks-এর ওপর।

#include <iostream>

int main()
{
    int marks[3] = {70, 85, 62};

    for (int x : marks) {
        x = 0;
    }
    std::cout << "after the copy form:   " << marks[0] << ' ' << marks[1] << ' ' << marks[2] << '\n';

    for (int& x : marks) {
        x *= 2;
    }
    std::cout << "after the change form: " << marks[0] << ' ' << marks[1] << ' ' << marks[2] << '\n';

    int best = 0;
    for (const auto& x : marks) {
        if (x > best) {
            best = x;
        }
    }
    std::cout << "best, by the read form: " << best << '\n';
    return 0;
}

after the copy form:   70 85 62
after the change form: 140 170 124
best, by the read form: 170

বদলানোর রূপটা ধাপে ধাপে দেখো। প্রতিটা পাকে x পরের বাক্সটার নাম হয়, আর তার নিচে array বদলে যায়।

কাজের programmer-রা যে নিয়ম মানে: খেলার জন্য copy চাইলে auto x, element বদলালে auto& x, আর শুধু পড়লে const auto& x। ছোট সংখ্যার copy-তে খরচ নেই; এর চেয়ে বড় কিছু হলে copy সত্যিকারের খরচ, যেটা নিচে মাপা হয়েছে।

#include <iostream>
#include <string>
#include <vector>

int main()
{
    std::vector<std::string> words = {"tea", "biscuit", "jam"};
    for (int i = 0; const auto& w : words) {
        std::cout << i << ": " << w << '\n';
        i++;
    }
    return 0;
}

0: tea
1: biscuit
2: jam

Module 0-তে দেখা container-গুলোর ওপর range-for

একই loop প্রতিটা STL container-এ চলে, আসল কথাটা এটাই। পরের module-গুলো ঠিকমতো শেখাবে এমন দুইটা container-এর ওপর একটা করে program এখানে। std::vector হলো এমন array যে নিজের size জানে (Module 2)। std::map key আর value-র জোড়া রাখে, key-র ক্রমে সাজিয়ে (Module 9)।

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> laps = {62, 58, 61, 57};
    int fastest = laps[0];

    for (int t : laps) {
        if (t < fastest) {
            fastest = t;
        }
    }
    std::cout << laps.size() << " laps, fastest " << fastest << " s\n";
    return 0;
}

4 laps, fastest 57 s

#include <iostream>
#include <map>
#include <string>

int main()
{
    std::map<std::string, int> stock = {{"tea", 12}, {"jam", 3}, {"bread", 7}};

    for (const auto& item : stock) {
        std::cout << item.first << ": " << item.second << '\n';
    }
    return 0;
}

bread: 7
jam: 3
tea: 12

Map তার item-গুলো print করেছে key-র বর্ণানুক্রমে, যে ক্রমে লেখা হয়েছিল সেভাবে না, কারণ map তার key-গুলো সাজিয়ে রাখে। প্রতিটা item একটা জোড়া, আর .first আর .second তার দুই অংশ; pair শেখাবে lesson 06। এখানে element-এর type বেশ লম্বা, std::pair<const std::string, int>, আর ঠিক এখানেই const auto& তার দাম দেয়।

মানে array, vector, map, সবগুলোর ওপর range-for পড়তে একই রকম। একবার শিখে নাও, এই track-এর প্রতিটা container এটা দিয়েই খোলে।

Copy-র ফাঁদ, মেপে দেখা

Kenji লেখে for (auto t : titles), কারণ এটাই সবচেয়ে ছোট। সংখ্যার list হলে ঠিক আছে। কিন্তু string-এর list হলে প্রতিটা পাকে body শুরু হওয়ার আগেই পুরো একটা string copy হয়।

#include <chrono>
#include <iostream>
#include <string>
#include <vector>

int main()
{
    std::vector<std::string> titles(100000, std::string(100, 'x'));

    auto t0 = std::chrono::steady_clock::now();
    long long a = 0;
    for (int round = 0; round < 10; round++) {
        for (auto t : titles) {
            a += t.size();
        }
    }
    auto t1 = std::chrono::steady_clock::now();
    long long b = 0;
    for (int round = 0; round < 10; round++) {
        for (const auto& t : titles) {
            b += t.size();
        }
    }
    auto t2 = std::chrono::steady_clock::now();

    std::chrono::duration<double, std::milli> byCopy = t1 - t0;
    std::chrono::duration<double, std::milli> byRef = t2 - t1;
    std::cout << "auto t:        " << a << " characters in " << byCopy.count() << " ms\n";
    std::cout << "const auto& t: " << b << " characters in " << byRef.count() << " ms\n";
    return 0;
}

List-এ আছে 100টা character-এর 100,000টা string, আর প্রতিটা loop এটা 10 বার ঘোরে। এটা Compiler Explorer-এ একবারের run, x86-64 GCC 12.2, Playground-এর flag-এ, -O2 -std=c++17।

উত্তর একই, কিন্তু ওই run-এ 26 গুণ ধীর; পরে আরও তিনবার চালালে এসেছে 16 থেকে 22 ms, যেখানে অন্যটা 1 ms-এর মতো, মানে 15 থেকে 24 গুণ। পুরো তফাতটাই copy-র: দশ লাখ string বানানো আর ফেলে দেওয়া, শুধু এমন একটা সংখ্যা পড়ার জন্য যেটা প্রতিটা string আগে থেকেই জানত। তাই সংখ্যার চেয়ে বড় কিছু পড়ার default হলো const auto&।

auto-র যে কাজ পরে আসবে

auto function-এর return type-এর জায়গাতেও বসতে পারে, যেমন auto half(int n), আর compiler type-টা নেয় return statement থেকে। এই track এখনো সেটা ব্যবহার করে না। Function কী ফেরত দেয়, পাঠক সেটা দেখে তার প্রথম লাইনে, তাই এই module return type লিখে রাখে। Module 12 আবার auto ব্যবহার করবে, একটা lambda রাখতে, যার type লেখাই যায় না।

মানে এই module-এ auto আসে শুধু দুই জায়গায়: মান সহ একটা variable-এ, আর range-for-এর declaration-এ।

#include <iostream>

int main()
{
    double prices[4] = {1.5, 2.25, 0.75, 4.0};
    double total = 0;

    for (auto p : prices) {
        total += p;
    }
    std::cout << "basket: " << total << '\n';
    return 0;
}

basket: 8.5

#include <iostream>

int main()
{
    double temps[5] = {21.5, 25, 18, 30, -5};

    for (auto& t : temps) {
        t = t * 9 / 5 + 32;
    }
    std::cout << "Fahrenheit:";
    for (auto t : temps) {
        std::cout << ' ' << t;
    }
    std::cout << '\n';
    return 0;
}

Fahrenheit: 70.7 77 64.4 86 23

#include <iostream>
#include <string>
#include <vector>

int main()
{
    int n = 0;
    std::cin >> n;

    std::vector<std::string> titles(n);
    for (auto& t : titles) {
        std::cin >> t;
    }

    char letter = ' ';
    std::cin >> letter;

    int found = 0;
    for (const auto& t : titles) {
        if (t[0] == letter) {
            std::cout << t << '\n';
            found++;
        }
    }
    std::cout << found << " of " << titles.size() << " start with " << letter << '\n';
    return 0;
}

Dune
Dracula
2 of 5 start with D

for (auto x : marks) {
    x *= 2;
}

auto x;
x = 5;

auto total = 0;
total += 2.5;
total += 2.5;

void printAll(int a[])
{
    for (int x : a) {
        std::cout << x << ' ';
    }
}

#include <iostream>

int main()
{
    auto x = {1, 2, 3};
    std::cout << x.size() << '\n';
    return 0;
}

#include <iostream>
#include <vector>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n = 0;
    std::cin >> n;

    // A vector is an array that knows its own size (Module 2 teaches it),
    // so a range-for over it walks exactly the n values.
    std::vector<long long> values(n);
    for (long long& x : values) {
        std::cin >> x;
    }

    // Double every value in place with a range-for. Then print the
    // values on one line, separated by single spaces.

    return 0;
}

#include <iostream>
#include <string>
#include <vector>

int main()
{
    int n = 0;
    std::cin >> n;

    // A vector of n strings (Module 2), read with a range-for.
    std::vector<std::string> words(n);
    for (auto& w : words) {
        std::cin >> w;
    }

    // Walk words with a range-for and keep the longest one.
    // A string's length is w.size().

    return 0;
}

এরপর lesson 05 বোঝাবে std::vector<long long>-এর angle bracket-গুলো: একটা template, একটা type দিয়ে ভরা।