আউটপুট কী হবে? — C++ কোড পড়ার অনুশীলন

(সহজ) double-এ রাখলেই কি দশমিক আসে?

int a = 7, b = 2;
double d = a / b;
std::println("{} {}", d, a / 2.0);

• 3.5 3.5
• 3 3.5
• 3.0 3.5
• 3 3

(মাঝারি) auto কোন টাইপ ধরল — কী ছাপা হবে?

auto x = 5 / 2;
auto y = 5 / 2.0f;
auto z = 'a' + 1;
std::println("{} {} {}", x, y, z);

• 2.5 2.5 b
• 2 2.5 b
• 2 2.5 98
• 2 2 98

(মাঝারি) cout-এর << আর shift-এর << — কী ছাপা হবে?

std::cout << 1 << 2 + 3 << ' '
          << (1 << 2) + 3 << '\n';

• 15 7
• 7 7
• 1 5 7
• 15 32

(কঠিন) Signed আর unsigned তুলনা — কী ছাপা হবে?

int i = -1;
unsigned u = 1;
std::cout << (i < u) << '\n';

• 1
• 0
• false
• Undefined behavior

(মাঝারি) std::format-এর width আর alignment — ঠিক কী দেখা যাবে?

std::println("[{:>5}] [{:<4}] [{:05.1f}]",
             42, "ab", 3.14159);

• [42] [ab] [3.1]
• [42 ] [ ab] [003.1]
• [ 42] [ab ] [003.1]
• [ 42] [ab ] [ 3.14]

(মাঝারি) Brace initialization-এ দশমিক সংখ্যা

int x{3.5};
std::println("{}", x);

• 3
• 4
• Compile error
• Undefined behavior

(সহজ) range-for-এ কপি না reference?

std::vector<int> v{1, 2, 3};
for (auto x : v) x *= 2;
for (auto& y : v) y += 1;
for (int z : v) std::print("{} ", z);

• 3 5 7
• 2 3 4
• 1 2 3
• 4 6 8

(মাঝারি) কোন overload চলবে?

void f(int)    { std::print("int "); }
void f(double) { std::print("double "); }

f('a');  f(2.5f);  f(true);

• int double int
• int int int
• int double double
• Compile error: ambiguous

(কঠিন) একই দুটি overload, এবার long দিয়ে ডাক

void f(int)    { std::print("int "); }
void f(double) { std::print("double "); }

f(5L);

• int
• double
• Compile error: no matching function
• Compile error: ambiguous

(মাঝারি) Reference-কে কি অন্য ভ্যারিয়েবলে সরানো যায়?

int a = 1;
int& r = a;
int b = 5;
r = b;
b = 9;
std::println("{} {} {}", a, r, b);

• 1 5 9
• 1 9 9
• 5 5 9
• 9 9 9

(কঠিন) static counter, তিনবার এক লাইনে

int counter() { static int c = 0; return ++c; }

std::println("{} {} {}", counter(), counter(), counter());

• 1 2 3
• 3 2 1
• Undefined behavior
• Unspecified — ক্রম নির্দিষ্ট নয়

(মাঝারি) Structured binding — কপি নাকি আসলটি?

std::pair p{1, 2};
auto [x, y] = p;
x = 10;
auto& [u, v] = p;
v = 20;
std::println("{} {} {}", p.first, p.second, x);

• 10 20 10
• 1 20 10
• 1 2 10
• 1 20 1

(সহজ) গোল বন্ধনী আর বাঁকা বন্ধনী — vector-এ কতটি element?

std::vector<int> a(3, 7), b{3, 7};
std::println("{} {} {}", a.size(), b.size(), a[2]);

• 3 3 7
• 2 2 7
• 3 2 7
• 3 2 3

(মাঝারি) String literal-এ + 1

std::string t = "abc" + 1;
std::string u = std::string("abc") + "1";
std::println("{} {}", t, u);

• abc1 abc1
• bc abc1
• abcb abc1
• Compile error

(মাঝারি) দুটি string literal জোড়া

std::string s = "Dhaka" + " city";
std::println("{}", s);

• Dhaka city
• Dhaka
• Undefined behavior
• Compile error

(মাঝারি) unique_ptr move করার পরে

auto p = std::make_unique<int>(5);
auto q = std::move(p);
std::println("{} {}", p == nullptr, *q);

• true 5
• 1 5
• false 5
• Compile error

(মাঝারি) shared_ptr-এর use_count

auto a = std::make_shared<int>(1);
auto b = a;
{
    auto c = a;
    std::print("{} ", a.use_count());
}
std::print("{} ", a.use_count());
b.reset();
std::println("{}", a.use_count());

• 2 1 0
• 3 2 1
• 3 3 2
• 3 2 0

(কঠিন) local ভ্যারিয়েবলের reference ফেরত — C++23-এ কী হয়?

int& f() {
    int x = 5;
    return x;
}
int main() { std::println("{}", f()); }

• 5
• Undefined behavior
• Compile error
• 0

(কঠিন) temporary string-এর ওপর string_view

std::string_view sv = std::string("hello") + " world";
std::cout << sv << '\n';

• hello world
• hello
• Compile error
• Undefined behavior

(মাঝারি) Base, member আর নিজের শরীর — কোন ক্রমে?

struct A { A() { print("A"); } ~A() { print("a"); } };
struct B { B() { print("B"); } ~B() { print("b"); } };
struct C : A {
    B b;
    C()  { print("C"); }
    ~C() { print("c"); }
};
int main() { C c; }

• CABcba
• ABCcba
• ABCabc
• BACcab

(কঠিন) Initializer list-এর ক্রম উল্টে লিখলে?

struct M { M(const char* n) { std::print("{}", n); } };
struct S {
    M x{"x"};
    M y{"y"};
    S() : y("Y"), x("X") {}
};
int main() { S s; }

• XY
• YX
• xyXY
• Compile error

(কঠিন) Copy elision — কতবার কপি বা move?

struct T {
    T()           { print("ctor "); }
    T(const T&)   { print("copy "); }
    T(T&&)        { print("move "); }
    ~T()          { print("dtor "); }
};
T make() { return T{}; }
int main() { T t = make(); }

• ctor dtor
• ctor move dtor dtor
• ctor copy dtor dtor
• ctor move move dtor dtor dtor

(কঠিন) vector-এ push_back — copy নাকি move? (T ওপরের প্রশ্নের মতো, move constructor-টি noexcept)

std::vector<T> v;
v.reserve(2);
T t;
v.push_back(t);
v.push_back(std::move(t));
// এরপর main শেষ

• ctor move move dtor dtor dtor
• ctor copy move move dtor dtor dtor
• ctor copy move dtor dtor dtor
• ctor copy copy dtor dtor dtor

(মাঝারি) virtual, non-virtual আর মান হিসেবে কপি

struct Base {
    virtual ~Base() = default;
    virtual void hi() { print("Base "); }
    void bye()        { print("base "); }
};
struct Der : Base {
    void hi() override { print("Der "); }
    void bye()         { print("der "); }
};
Der d;
Base& b = d;   b.hi();  b.bye();
Base s = d;    s.hi();

• Der der Der
• Der base Base
• Base base Base
• Der base Der

(কঠিন) Constructor-এর ভেতরে virtual ডাক

struct B {
    B() { hello(); }
    virtual ~B() = default;
    virtual void hello() { print("B"); }
};
struct D : B {
    D() { hello(); }
    void hello() override { print("D"); }
};
int main() { D d; }

• DD
• BB
• BD
• Compile error

(কঠিন) Virtual ফাংশনের default argument

struct B {
    virtual ~B() = default;
    virtual void f(int x = 1) { print("B{} ", x); }
};
struct D : B {
    void f(int x = 2) override { print("D{} ", x); }
};
D d;
B& b = d;
b.f();  d.f();

• D1 D2
• D2 D2
• B1 D2
• Compile error

(কঠিন) Virtual destructor ছাড়া base pointer দিয়ে delete

struct Base { ~Base() { print("~Base "); } };
struct Der : Base { ~Der() { print("~Der "); } };

Base* p = new Der;
delete p;

• ~Der ~Base
• ~Base
• Compile error
• Undefined behavior

(মাঝারি) Template-এ দুটি ভিন্ন টাইপ

template <class T>
T mx(T a, T b) { return a > b ? a : b; }

std::println("{}", mx(3, 4.5));

• 4.5
• 4
• Compile error
• Undefined behavior

(কঠিন) Template বনাম সাধারণ ফাংশন — কে জিতবে?

template <class T> void f(T) { print("T "); }
void f(int)                  { print("int "); }

f(1);  f(1.0);  f('a');

• int T int
• int T T
• T T T
• Compile error: ambiguous

(মাঝারি) map-এর ক্রম আর operator[]

std::map<std::string, int> m{
    {"rice", 3}, {"egg", 12}, {"dal", 2}};
for (const auto& [k, v] : m) std::print("{} ", k);
m["fish"];
std::println("| {} {}", m.size(), m["fish"]);

• dal egg rice | 4 0
• rice egg dal | 4 0
• dal egg rice | 3 0
• dal egg rice | এরপর std::out_of_range

(মাঝারি) unordered_map ঘুরলে কোন ক্রমে key আসবে?

std::unordered_map<std::string, int> m{
    {"a", 1}, {"b", 2}, {"c", 3}, {"d", 4}};
for (const auto& [k, v] : m) std::print("{} ", k);

• a b c d
• d c b a
• Undefined behavior
• চারটি key, কিন্তু ক্রম নির্দিষ্ট নয়

(কঠিন) erase ছাড়া std::remove

std::vector<int> v{1, 2, 3, 2, 5};
auto it = std::remove(v.begin(), v.end(), 2);
std::println("{} {} {} {} {}",
             v.size(), it - v.begin(), v[0], v[1], v[2]);

• 3 3 1 3 5
• 5 3 1 3 5
• 5 3 1 2 3
• 5 2 1 3 5

(মাঝারি) stable_sort — সমান key-এর ক্রম

std::vector<std::pair<int, char>> v{
    {2, 'a'}, {1, 'b'}, {2, 'c'}, {1, 'd'}};
std::ranges::stable_sort(v, {}, &std::pair<int, char>::first);
for (auto& p : v) std::print("{}", p.second);

• abcd
• dbca
• bdac
• bdca

(কঠিন) mutable lambda — কার মান বাড়ল?

int c = 0;
auto f = [c]() mutable { return ++c; };
f();
f();
std::println("{} {}", f(), c);

• 3 3
• 3 0
• 1 0
• Compile error

(কঠিন) View কখন কাজ করে? (filter একটি ছাপার কাজ করে)

std::vector<int> v{1, 2, 3, 4, 5, 6};
auto r = v
  | std::views::filter([](int x) {
        std::print("f{} ", x); return x % 2 == 0; })
  | std::views::take(2);
std::println("start");
for (int x : r) std::print("[{}] ", x);

• f1 f2 f3 f4 f5 f6 start, তারপর [2] [4]
• start, তারপর f1 f2 [2] f3 f4 [4]
• start, তারপর f1 f2 f3 f4 [2] [4]
• start, তারপর f1 f2 [2] f3 f4 [4] f5 f6

(মাঝারি) const object-এ std::move

const std::string s = "hi";
std::string t = std::move(s);
std::println("{} {}", s, t);

• hi hi
• hi (s খালি)
• Compile error
• Undefined behavior

(মাঝারি) Move করার পরে উৎস string-এ কী থাকে?

std::string a = "rice";
std::string b = std::move(a);
std::println("{} [{}]", b, a);

• rice [rice]
• Undefined behavior
• rice [ ] — a-এর মান unspecified (GCC-তে খালি)
• Compile error: a আর নেই

(মাঝারি) Stack unwinding — destructor-এর ক্রম

struct G { const char* n; ~G() { print("~{} ", n); } };
void f() { G a{"a"}; G b{"b"}; throw 1; }

try { G t{"t"}; f(); }
catch (int x) { print("catch{}", x); }

• catch1 ~b ~a ~t
• ~b ~a ~t catch1
• ~a ~b ~t catch1
• catch1

(মাঝারি) catch-এর ক্রম

try {
    throw std::out_of_range("x");
}
catch (const std::exception&)    { std::println("exception"); }
catch (const std::out_of_range&) { std::println("range"); }

• exception
• range
• exception range
• Compile error

(কঠিন) variant<bool, std::string>-এ একটি string literal

std::variant<bool, std::string> v = "abc";
std::println("{}", v.index());

• 0
• 1
• Compile error
• Undefined behavior

(কঠিন) Concepts — কোন overload?

void show(std::integral auto)       { print("int "); }
void show(std::floating_point auto) { print("float "); }
void show(auto)                     { print("other "); }

show(5); show(2.5); show('c'); show("hi");

• int float other other
• other other other other
• int float int other
• Compile error: ambiguous

(কঠিন) বিখ্যাত i = i++ + 1 — C++17 ও পরের মানে

int i = 5;
i = i++ + 1;
std::println("{}", i);

• 7
• 6
• Undefined behavior
• 5

(মাঝারি) কিন্তু i++ + i++?

int i = 5;
int j = i++ + i++;
std::println("{} {}", i, j);

• 7 11
• 7 10
• Compile error
• Undefined behavior

(মাঝারি) দুটি thread, একটি সাধারণ int

int plain = 0;
auto work = [&] { for (int k = 0; k < 100000; ++k) ++plain; };
std::thread a(work), b(work);
a.join();
b.join();
std::println("{}", plain);

• 200000
• 100000
• Compile error
• Undefined behavior

(কঠিন) join না করে std::thread ধ্বংস হলে

{
    std::thread t([] {});
}
std::println("end");

• end
• Undefined behavior
• কিছু ছাপে না — std::terminate
• Compile error

(কঠিন) while (!in.eof()) — কয়টি সংখ্যা গোনা হলো?

{ std::ofstream out("t.txt"); out << "10 20 30\n"; }
std::ifstream in("t.txt");
int a = 0, s = 0, n = 0;
while (!in.eof()) { in >> a; s += a; ++n; }
std::println("{} {} {}", n, s, a);

• 3 60 30
• 4 90 30
• 4 60 0
• অসীম লুপ

(মাঝারি) ofstream-এর open mode

{ std::ofstream o("a.txt"); o << "abc"; }
{ std::ofstream o("a.txt"); o << "d"; }
{ std::ofstream o("a.txt", std::ios::app); o << "e"; }
std::ifstream in("a.txt");
std::string s;
in >> s;
std::println("{}", s);

• de
• abcde
• dbce
• e