reference: একই বাক্সের দ্বিতীয় নাম

গত মাসে Maria C-তে একটা swap function লিখেছিল। ওটা দুইটা pointer নিত, প্রতিটা ব্যবহারের আগে একটা করে তারা বসাত, আর প্রতিটা call-এ লাগত একটা করে ampersand। Bob একটা তারা দিতে ভুলে গিয়েছিল, আর সেই ভুল খুঁজতে ওর পুরো একটা সন্ধ্যা গেছে। C++-এ একই function লেখা যায় কোনো তারা ছাড়া, call-এ কোনো ampersand ছাড়া। এর নাম reference, আর এর পরের প্রতিটা STL lesson দাঁড়িয়ে আছে এটার ওপর ভর দিয়ে।

Maria-র swap, C-তে আর C++-এ

এই হলো Maria-র C version। C-তে function তার argument-গুলোর copy পায়, তাই caller-এর x আর y বদলাতে হলে ওর লাগে ওদের address।

#include <stdio.h>

void swap_ptr(int *a, int *b)
{
    int keep = *a;
    *a = *b;
    *b = keep;
}

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

    swap_ptr(&x, &y);
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

x = 5, y = 3

আর এই হলো C++-এ একই কাজ, reference দিয়ে।

#include <iostream>

void swapRef(int& a, int& b)
{
    int keep = a;
    a = b;
    b = keep;
}

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

    swapRef(x, y);
    std::cout << "x = " << x << ", y = " << y << '\n';
    return 0;
}

x = 5, y = 3

Output একদম এক। বদলেছে তিনটা জিনিস, table-এ সেগুলো পাশাপাশি রাখা হলো।

মানে C++-এর swap একই কাজ করে, call-এ কোনো address নেওয়া লাগে না, আর function-এর ভিতরেও কোনো তারা লাগে না।

Reference মানে একই বাক্সের দ্বিতীয় নাম

Reference হলো আগে থেকে থাকা একটা variable-এর দ্বিতীয় নাম। এটা copy না, আবার address রাখা আলাদা কোনো variable-ও না। Reference-এর ওপর যা করবে, সেটা আসলে হবে মূল বাক্সটার ওপরেই।

type& name = existing_variable;

দুই নামের একটা বাক্স চোখের সামনে দেখো।

#include <iostream>

int main()
{
    int score = 7;
    int& r = score;

    std::cout << "score = " << score << ", r = " << r << '\n';
    r = 8;
    std::cout << "after r = 8, score = " << score << '\n';
    score = 9;
    std::cout << "after score = 9, r = " << r << '\n';
    std::cout << "same box: " << (&r == &score) << '\n';
    return 0;
}

score = 7, r = 7
after r = 8, score = 8
after score = 9, r = 9
same box: 1

r দিয়ে লিখলে score বদলে গেল, আবার score-এ লিখলে r যা পড়ে সেটাও বদলে গেল। শেষ লাইনটা জিজ্ঞেস করে, দুই নামের address কি একই? সত্যি comparison-কে std::cout print করে 1 হিসেবে, তাই উত্তর হলো হ্যাঁ।

ছবিটা এরকম। বাঁ দিকে একটা বাক্স, তার গায়ে দুইটা নাম। ডান দিকে তুলনার জন্য একটা pointer, p = &score: pointer নিজেই আরেকটা বাক্স, তার নিজের address আছে, আর ভিতরে রাখা আছে প্রথম বাক্সের address।

তাই r হলো না score-এর copy, না তার pointer। এটা score-ই, শুধু দ্বিতীয় একটা নামে।

& কেন দুই রকম মানে দেয়

Maria সাথে সাথে ধরে ফেলল: C-তে তো & মানে ছিল "এর address"। এখন এর মানে "এর reference"-ও। দুইটাই সত্যি, আর চিহ্নটা কোথায় দাঁড়িয়ে আছে, সেটাই বলে দেয় কোনটা।

#include <iostream>

int main()
{
    int x = 5;
    int& r = x;
    int* p = &x;

    std::cout << r << ' ' << *p << '\n';
    std::cout << (6 & 3) << '\n';
    return 0;
}

5 5
2

তাই &-এর বাঁ পাশটা দেখো। বাঁয়ে type থাকলে reference, বাঁয়ে কিছু না থাকলে address, আর দুই পাশে দুইটা মান থাকলে bitwise AND।

Reference দিয়ে পাঠানো: function কাজ করে caller-এর বাক্সেই

Function-এর parameter-ও reference হতে পারে। তখন call যতক্ষণ চলে, parameter-টা থাকে caller-এর variable-এর দ্বিতীয় নাম হয়ে। একে বলে passing by reference। সাধারণ যে পথে function নিজের একটা copy পায়, সেটা passing by value।

Maria-র swapRef(x, y) ধাপে ধাপে দেখো। Call শুরু হতেই a আর b হয়ে যায় main-এর বাক্সগুলোর দ্বিতীয় নাম, তাই ভিতরে কিছু copy হয়ে ঢোকে না, ফেরত পাঠানোরও কিছু থাকে না।

Reference parameter থাকলে একটা function একাধিক ফলও ফেরত দিতে পারে। Kenji-র দোকানের till প্রতিটা বিক্রি দুইটা চলতি হিসাবে টুকে রাখে।

#include <iostream>

void addSale(int price, int& count, long long& total)
{
    count = count + 1;
    total = total + price;
}

int main()
{
    int count = 0;
    long long total = 0;

    addSale(120, count, total);
    addSale(80, count, total);
    addSale(45, count, total);
    std::cout << count << " sales, total " << total << '\n';
    return 0;
}

3 sales, total 245

price যায় value হিসেবে, কারণ function এটা শুধু পড়ে। count আর total যায় reference হিসেবে, কারণ function-কে main-এর নিজের দুইটা বাক্স বদলাতে হবে।

Bob এখানে একটা জিনিস খেয়াল করল। scanf("%d", &x)-এ ampersand লাগে, অথচ std::cin >> x-এ লাগে না। কারণটা এই lesson-ই: int পড়ার >> তার ডান পাশেরটা নেয় int& হিসেবে। তাই std::cin সরাসরি তোমার বাক্সে লেখে, আর ampersand-টা উধাও হয়ে যায়।

মানে reference parameter দিয়ে function caller-এর নিজের বাক্সেই কাজ করে, C ঠিক এই কাজটাই করত pointer দিয়ে, শুধু তারাগুলো ছাড়া।

Reference যে তিনটা নিয়ম মানে

Pointer খালি থাকতে পারে, অন্য দিকে ঘুরিয়ে দেওয়া যায়, আবার কোনো মান ছাড়াও ফেলে রাখা যায়। Reference এগুলোর কোনোটাই পারে না। প্রতিটা নিয়ম হয় compiler নিজে check করে, নয়তো একটা run দেখিয়ে দেয়।

নিয়ম 1: জন্মের সময়ই reference একটা বাক্সের নাম নিয়ে আসে। বাক্স ছাড়া reference compiler মানে না।

int& r;

GCC 12 Playground-এর command line-এ আর -Wall -Wextra-এ একই কথা বলে: error: 'r' declared as reference but not initialized।

নিয়ম 2: reference কখনো null হয় না। "কিছুই না"-র reference দিয়ে শুরু করার কোনো উপায় নেই।

int& r = nullptr;

GCC 12 প্রতিটা command line-এ এটা ফিরিয়ে দেয়: error: invalid initialization of non-const reference of type 'int&' from an rvalue of type 'std::nullptr_t'। nullptr হলো C++-এর null pointer, C-র NULL, শুধু তার নিজের একটা type আছে।

নিয়ম 3: reference কখনো অন্য বাক্সে সরে যায় না। এটা compile হয়ে যায়, তাই খেয়াল করে দেখো কী ঘটে।

#include <iostream>

int main()
{
    int a = 10;
    int b = 20;
    int& r = a;

    r = b;
    r = 99;
    std::cout << a << ' ' << b << ' ' << r << '\n';
    return 0;
}

99 20 99

r = b; দেখে মনে হয় r এখন থেকে b-এর নাম। আসলে না: এটা 20 copy করে a-তে, যে বাক্সের নাম r জন্ম থেকে বহন করছে। তাই r = 99-ও গিয়ে পড়ে a-তে, আর b-এর 20 যেমন ছিল তেমনই থাকে।

মানে reference একবারই ঠিক হয়, declaration-এর লাইনে, একটা আসল বাক্সের সাথে, আর scope শেষ না হওয়া পর্যন্ত সেই বাক্সেরই নাম থাকে।

const&: বড় জিনিস copy না করেই পড়া

Value হিসেবে পাঠালে argument-টা copy হয়। একটা int-এর জন্য সেটা চার byte, কেউ টেরও পায় না। কিন্তু দশ লাখ সংখ্যার একটা list হলে সেটা চল্লিশ লাখ byte, আর প্রতিটা call-এ আবার নতুন করে copy।

Const reference, লেখা হয় const type&, function-কে caller-এর বাক্সটাই দেয়, তবে শুধু পড়ার একটা নামে। কিছুই copy হয় না, আর function কথা দেয় যে বাক্সটা বদলাবে না। Compiler সেই কথা রাখতে বাধ্য করে।

void show(const int& x)
{
    x = 7;
}

GCC 12, প্রতিটা command line-এ: error: assignment of read-only reference 'x'।

এবার খরচটা মেপে দেখা যাক। Program-টা std::vector দিয়ে 1,000,000টা int-এর একটা list বানায়; vector হলো এমন array যে নিজের size জানে, Module 2-তে এটা শেখানো হবে। List-টার যোগফল বের করে 100 বার value parameter দিয়ে, তারপর 100 বার const& parameter দিয়ে, আর দুইটারই সময় মাপে <chrono> দিয়ে, যেটা standard ঘড়ি।

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

long long sumByValue(std::vector<int> v)
{
    long long total = 0;
    for (int i = 0; i < (int)v.size(); i++) {
        total += v[i];
    }
    return total;
}

long long sumByConstRef(const std::vector<int>& v)
{
    long long total = 0;
    for (int i = 0; i < (int)v.size(); i++) {
        total += v[i];
    }
    return total;
}

int main()
{
    std::vector<int> big(1000000, 1);
    const int calls = 100;

    auto t0 = std::chrono::steady_clock::now();
    long long a = 0;
    for (int c = 0; c < calls; c++) {
        a += sumByValue(big);
    }
    auto t1 = std::chrono::steady_clock::now();
    long long b = 0;
    for (int c = 0; c < calls; c++) {
        b += sumByConstRef(big);
    }
    auto t2 = std::chrono::steady_clock::now();

    std::chrono::duration<double, std::milli> byValue = t1 - t0;
    std::chrono::duration<double, std::milli> byRef = t2 - t1;
    std::cout << "by value:     " << a << " in " << byValue.count() << " ms\n";
    std::cout << "by const ref: " << b << " in " << byRef.count() << " ms\n";
    return 0;
}

সময়গুলো প্রতিবার run-এ একটু একটু বদলায়, তাই এগুলো output block-এ না রেখে table-এ রাখা হলো। এটা Compiler Explorer-এ একবারের run, x86-64 GCC 12.2, Playground-এর flag-এ, -O2 -std=c++17।

দুইটাই একই যোগফল দেয়। Value version প্রায় 2.7 গুণ ধীর, আর বাড়তি প্রতিটা millisecond খরচ হয়েছে copy করতে: যে সংখ্যাগুলো কখনো বদলায়নি, সেগুলো পড়ার জন্য 100টা call-এ 400 MB টানাটানি।

প্রচলিত পরামর্শটা C++ Core Guidelines-এর, rule F.16: int, double, char-এর মতো ছোট জিনিস value হিসেবে পাঠাও, আর এর চেয়ে বড় যেকোনো কিছু const& দিয়ে। তাই বড় জিনিস পড়ার পথ হলো const&: caller-এর নিজের বাক্স, শুধু পড়ার জন্য, copy-র কোনো খরচ ছাড়া।

আগাম এক ঝলক: reference দিয়ে range-for

Lesson 04 শেখাবে range-for, এমন একটা loop যেটা array-র প্রতিটা বাক্সে একে একে যায়। এর একটা অংশ এখানেই মানায়, কারণ সেটাও আবার reference।

#include <iostream>

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

    for (int m : marks) {
        m = m + 5;
    }
    std::cout << "after a copy loop:      " << marks[0] << ' ' << marks[3] << '\n';

    for (int& m : marks) {
        m = m + 5;
    }
    std::cout << "after a reference loop: " << marks[0] << ' ' << marks[3] << '\n';
    return 0;
}

after a copy loop:      70 91
after a reference loop: 75 96

প্রথম loop-এ m প্রতিটা বাক্সের একটা copy, তাই তাতে 5 যোগ করলে marks-এ কিছুই বদলায় না। দ্বিতীয়টায় m একে একে প্রতিটা বাক্সের দ্বিতীয় নাম, তাই নম্বরগুলো সত্যিই বদলে যায়। পুরো ফারাকটা একটা &-এর।

Pointer নাকি reference: কখন কোনটা

Reference pointer-কে সরিয়ে দেয় না। দুইটাই এমন কাজ পারে যা অন্যটা পারে না, table-এ দুইটা পাশাপাশি রাখা হলো।

Function যে parameter বদলাবে, তার জন্য reference নাও, আর যে বড় জিনিস শুধু পড়বে, তার জন্য const&। Pointer নাও তখন, যখন "কিছুই না" একটা আসল উত্তর, যখন array ধরে এগোতে হবে, বা যখন code-টা C-র সাথে ভাগ করে চলে। STL প্রায় সব জায়গায় তোমার হাতে reference দেয়, আর pointer-এর মতো যে একটা জিনিস সে যোগ করে, iterator, সেটা দেখাবে Module 11।

#include <iostream>

void clampTemp(int& t, int low, int high)
{
    if (t < low) {
        t = low;
    }
    if (t > high) {
        t = high;
    }
}

int main()
{
    int a = 25;
    int b = -55;
    int c = 70;

    clampTemp(a, -40, 60);
    clampTemp(b, -40, 60);
    clampTemp(c, -40, 60);
    std::cout << a << ' ' << b << ' ' << c << '\n';
    return 0;
}

25 -40 60

#include <iostream>

bool readMark(int& mark)
{
    std::cin >> mark;
    return mark >= 0 && mark <= 100;
}

int main()
{
    int mark = 0;
    int good = 0;
    int bad = 0;

    for (int i = 0; i < 4; i++) {
        if (readMark(mark)) {
            good++;
        } else {
            bad++;
            std::cout << "rejected " << mark << '\n';
        }
    }
    std::cout << good << " good, " << bad << " bad\n";
    return 0;
}

rejected 120
rejected -3
2 good, 2 bad

#include <iostream>
#include <string>

const int MAX_N = 100;

void applyDiscount(int& price, int percent)
{
    price = price - price * percent / 100;
}

void printList(const std::string& shop, const int prices[], int n)
{
    std::cout << shop << ':';
    for (int i = 0; i < n; i++) {
        std::cout << ' ' << prices[i];
    }
    std::cout << '\n';
}

int main()
{
    int prices[MAX_N] = {0};
    int n = 0;
    int percent = 0;
    std::string shop = "Amara's Books";

    std::cin >> n;
    for (int i = 0; i < n; i++) {
        std::cin >> prices[i];
    }
    std::cin >> percent;

    printList(shop, prices, n);
    for (int i = 0; i < n; i++) {
        applyDiscount(prices[i], percent);
    }
    printList(shop, prices, n);
    return 0;
}

Amara's Books: 400 250 120 90
Amara's Books: 300 188 90 68

void swapValues(int a, int b)
{
    int keep = a;
    a = b;
    b = keep;
}

swapRef(3, 5);

int& bad()
{
    int local = 42;
    return local;
}

const int limit = 10;
int& r = limit;

#include <iostream>

int main()
{
    const int& r = 5;
    std::cout << r << '\n';
    return 0;
}

#include <iostream>

const int MAX_N = 100;

// Add bonus to mark, but never above 100.
void addBonus(int& mark, int bonus)
{
    // your code
}

int main()
{
    int marks[MAX_N] = {0};
    int n = 0;
    int bonus = 0;

    std::cin >> n;
    for (int i = 0; i < n; i++) {
        std::cin >> marks[i];
    }
    std::cin >> bonus;

    // Call addBonus on every mark, then print the marks on one line.

    return 0;
}

#include <iostream>

const int MAX_N = 100;

// Put the smallest of a[0] to a[n - 1] in lo and the largest in hi.
void minMax(const int a[], int n, int& lo, int& hi)
{
    // your code
}

int main()
{
    int a[MAX_N] = {0};
    int n = 0;

    std::cin >> n;
    for (int i = 0; i < n; i++) {
        std::cin >> a[i];
    }

    int lo = 0;
    int hi = 0;
    minMax(a, n, lo, hi);
    std::cout << lo << ' ' << hi << '\n';
    return 0;
}

#include <iostream>

// Put a and b in order: after the call, a <= b.
void order(int& a, int& b)
{
    // your code
}

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 0;
    std::cin >> t;
    for (int i = 0; i < t; i++) {
        int a = 0;
        int b = 0;
        int c = 0;
        std::cin >> a >> b >> c;

        // Use order() to put a, b and c in increasing order,
        // then print them on one line, separated by single spaces.
    }
    return 0;
}

এরপর lesson 04-এ auto দিয়ে type লেখার কাজটা compiler-কে দিয়ে দেবে, আর এই lesson যে range-for-এর এক ঝলক দেখাল, সেটা পুরোটা শিখবে।