MCQ প্রশ্নব্যাংক — C++-এর ৮৭টি প্রশ্নে যেকোনো পরীক্ষার প্রস্তুতি

(সহজ) C++ ভাষা মূলত কে তৈরি করেন?

• Dennis Ritchie
• Bjarne Stroustrup
• James Gosling
• Guido van Rossum

(সহজ) C++-এর প্রথম আন্তর্জাতিক (ISO) মানদণ্ড কোনটি?

• C++98
• C++03
• C++11
• C with Classes

(মাঝারি) Build করার সময় বার্তা এলো undefined reference to `area(double)'. এটি কোন ধাপের error?

• Preprocessor
• Compiler
• Runtime
• Linker

(মাঝারি) C++ compiler ফাংশনের নাম mangle করে (যেমন _Z4aread) মূলত কেন?

• কোড চুরি ঠেকাতে নাম লুকানো
• একই নামের ভিন্ন ফাংশন (overload) linker-এর কাছে আলাদা করতে
• link করা দ্রুত করতে
• executable-এর আকার ছোট করতে

(সহজ) auto x = 5u; — x-এর টাইপ কী?

• int
• unsigned int
• unsigned long
• Compile error

(মাঝারি) int n = 7; const int& r = n; auto a = r; — a-এর টাইপ কী?

• const int&
• const int
• int
• int&

(মাঝারি) int x{3.5}; লাইনটির কী হয়?

• x = ৩, চুপচাপ
• x = ৪, গোল করে
• Undefined behavior
• Compile error — narrowing

(মাঝারি) C++ মানদণ্ড কোন আকারটি সব প্ল্যাটফর্মে নিশ্চিত করে?

• sizeof(int) == 4
• sizeof(char) == 1
• sizeof(long) == 8
• sizeof(bool) == 1

(কঠিন) C++-এ sizeof('A')-এর মান কত?

• ১
• ২
• ৪
• ৮

(মাঝারি) int x = 1; থাকলে কোন ঘোষণায় *p = 5; চলবে, কিন্তু p = &y; compile হবে না?

• const int* p = &x;
• int const* p = &x;
• int* const p = &x;
• const int* const p = &x;

(সহজ) কী ছাপা হবে?

std::cout << -7 / 2 << ' ' << -7 % 2;

• -4 1
• -3 -1
• -3 1
• -4 -1

(মাঝারি) int i = 0; bool b = (i != 0) && (10 / i > 1); — কী ঘটে?

• শূন্য দিয়ে ভাগ — undefined behavior
• b = true
• b = false, ভাগটি কখনো হয় না
• Compile error

(সহজ) std::endl আর '\n'-এর পার্থক্য কী?

• std::endl নতুন লাইনের সাথে stream flush-ও করে
• std::endl Windows-এ দুটি অক্ষর লেখে, '\n' একটি
• '\n' শুধু C-তে চলে, C++-এ নয়
• কোনো পার্থক্য নেই

(মাঝারি) x = 2 হলে কী ছাপা হবে? (কোনো case-এ break নেই)

switch (x) {
  case 1: std::cout << "a";
  case 2: std::cout << "b";
  case 3: std::cout << "c";
  default: std::cout << "d";
}

• b
• bc
• bcd
• abcd

(মাঝারি) কোন জোড়া ঘোষণা একসাথে একই scope-এ রাখা যায় না?

• void f(int); আর void f(double);
• void f(int); আর void f(int, int);
• int f(int); আর double f(int);
• void f(int&); আর void f(const int&);

(মাঝারি) void f(int); আর void f(double); দুটিই আছে। f('a') কোনটি ডাকে?

• f(int)
• f(double)
• Ambiguous — compile error
• কোনোটিই নয় — compile error

(মাঝারি) শেষে a আর b-এর মান কত?

int a = 1, b = 2;
int& r = a;
r = b;
r = 5;

• a = 2, b = 5
• a = 5, b = 2
• a = 2, b = 2
• Compile error — reference আবার বাঁধা যায় না

(মাঝারি) std::vector<int> v{1, 2, 3}; for (auto x : v) x *= 2; — পরে v-তে কী থাকে?

• 2 4 6
• অপরিবর্তিত — 1 2 3
• Undefined behavior
• Compile error

(মাঝারি) void f(int a, int b = 2, int c); — এই ঘোষণার কী হয়?

• বৈধ; f(1) ডাকা যাবে
• বৈধ; c নিজে থেকে ০ হয়
• Compile error — ডিফল্ট আর্গুমেন্ট শেষের দিকে থাকতে হয়
• Linker error

(মাঝারি) enum class Color { Red, Green }; int x = Color::Red; — কী হয়?

• Compile error — নিজে থেকে int-এ রূপান্তর হয় না
• x = 0
• x = 1
• Undefined behavior

(সহজ) header ফাইলে using namespace std; লেখাকে খারাপ অভ্যাস বলা হয় কেন?

• প্রোগ্রাম চলার সময় ধীর হয়ে যায়
• header-এ এটি compile error
• যে ফাইল এটি include করবে, তাতেও std-এর সব নাম ঢুকে নামের সংঘর্ষ ঘটাতে পারে
• এতে std namespace মুছে যায়

(সহজ) std::vector<int> v; v.reserve(100); — এরপর v.size() কত?

• ১০০
• ০
• অনির্দিষ্ট — implementation ঠিক করে
• ১

(মাঝারি) v-তে ৩টি উপাদান। v.at(10) আর v[10] সম্পর্কে কোনটি সঠিক?

• দুটিই std::out_of_range ছোড়ে
• [] exception ছোড়ে, at() UB
• at() std::out_of_range ছোড়ে, [] undefined behavior
• দুটিই vector-কে ১১টি উপাদানে বাড়িয়ে নেয়

(মাঝারি) ৬৪-বিট Linux-এ GCC-র libstdc++-এ sizeof(std::string) কত?

• ৮
• ২৪
• ৩২
• লেখার দৈর্ঘ্যের ওপর নির্ভর করে

(কঠিন) std::string_view sv = std::string("Dhaka") + "!"; — এরপর std::cout << sv; লিখলে?

• Dhaka! নিশ্চিতভাবে
• Compile error
• খালি লাইন
• Undefined behavior — sv মরে যাওয়া temporary দেখায়

(মাঝারি) NULL-এর বদলে nullptr কেন ভালো?

• nullptr কোনো integer নয়, তাই overload-এ ভুল ফাংশন ডাকা হয় না
• nullptr dereference করলে crash হয় না
• nullptr মেমরিতে সব সময় ঠিকানা ০
• NULL শুধু C-তে আছে, C++-এ নেই

(মাঝারি) int* p = new int[10]; delete p; — কী হয়?

• ঠিকঠাক — পুরো array মুক্ত হয়
• Compile error
• Undefined behavior — new[]-এর সাথে delete[] লাগে
• শুধু প্রথম উপাদানটি মুক্ত হয়, বাকি ৯টি leak

(মাঝারি) auto p = std::make_unique<int>(5); auto q = p; — কী হয়?

• p আর q দুজনেই একই int-এর মালিক
• Compile error — unique_ptr কপি করা যায় না
• মালিকানা নিজে থেকে q-তে সরে, p খালি হয়
• Double delete — undefined behavior

(মাঝারি) শেষ লাইনে কী ছাপা হবে?

auto a = std::make_shared<int>(1);
auto b = a;
{ auto c = a; }
std::cout << a.use_count();

• ১
• ৩
• ২
• ০

(কঠিন) দুটি object একে অপরকে std::shared_ptr দিয়ে ধরে রাখে। বাইরের সব pointer চলে গেলে কী হয়, আর সমাধান কী?

• দুটিই ঠিকঠাক মুক্ত হয়; সমস্যা নেই
• Crash হয়; সমাধান unique_ptr
• Compile error; সমাধান auto
• Memory leak; সমাধান একটি দিকে std::weak_ptr

(মাঝারি) const int& f() { int x = 5; return x; } — int y = f(); লিখলে?

• Undefined behavior — dangling reference
• নিশ্চিতভাবে y = 5
• Compile error
• x-এর আয়ু বেড়ে y পর্যন্ত থাকে

(মাঝারি) RAII-এর মূল নিশ্চয়তা কোনটি?

• একটি garbage collector সময়মতো মেমরি মুক্ত করে
• object scope ছাড়লেই destructor resource ছেড়ে দেয় — exception এলেও
• প্রোগ্রামে কখনো exception আসে না
• প্রতিটি new-এর পরে প্রোগ্রামার নিজে delete ডাকেন

(সহজ) class-এর ভেতরে কোনো access specifier না লিখলে সদস্যরা কী হয়?

• public
• protected
• private
• Compile error

(মাঝারি) struct A { A(int) {} }; A a; — কী হয়?

• compiler ডিফল্ট constructor বানিয়ে a তৈরি করে
• Compile error — ডিফল্ট constructor নেই
• A(0) ডাকা হয়
• Undefined behavior

(সহজ) Rule of Three অনুযায়ী কোন তিনটির একটি নিজে লিখলে বাকি দুটিও লেখা উচিত?

• destructor, copy constructor, copy assignment
• ডিফল্ট constructor, destructor, copy constructor
• move constructor, move assignment, destructor
• operator==, operator<, operator<<

(কঠিন) একটি class-এ শুধু destructor নিজে লেখা হয়েছে (~T() {})। তখন move constructor-এর কী হয়?

• compiler স্বাভাবিকভাবে move constructor বানায়
• rvalue দিলে compile error
• copy আর move দুটিই নিষেধ হয়ে যায়
• move constructor তৈরি হয় না; “move” আসলে কপি হয়ে যায়

(মাঝারি) D d; একটি block-এর ভেতরে তৈরি হয়ে block শেষে ধ্বংস হলো। কী ছাপা হবে?

struct B { B() { std::cout << "B"; }
           ~B() { std::cout << "b"; } };
struct D : B { D() { std::cout << "D"; }
              ~D() { std::cout << "d"; } };

• DBdb
• BDbd
• BDdb
• Dd

(কঠিন) struct S { int a; int b; S() : b(1), a(b + 1) {} }; — S s;-এর পরে s.a কত?

• ২
• Undefined behavior — a তৈরির সময় b-তে মান বসেনি
• ১
• Compile error

(মাঝারি) কোন অপারেটরটি C++-এ overload করা যায় না?

• []
• ()
• ::
• <<

(মাঝারি) Base-এ void f(); (virtual নয়) আর virtual void g();; Der দুটিই override/hide করেছে। Base* p = new Der; p->f(); p->g(); — কোনগুলো চলে?

• Der::f, Der::g
• Base::f, Der::g
• Base::f, Base::g
• Der::f, Base::g

(কঠিন) Base-এর destructor virtual নয়। Base* p = new Derived; delete p; — কী হয়?

• প্রথমে ~Derived, তারপর ~Base — স্বাভাবিক
• Compile error
• শুধু ~Base চলে — নিশ্চিতভাবে, এটি নির্ধারিত আচরণ
• Undefined behavior

(মাঝারি) g() virtual এবং Der-এ override করা। Der d; Base b = d; b.g(); — কোনটি চলে, কেন?

• Base::g — object slicing
• Der::g — virtual বলে
• Compile error
• Undefined behavior

(মাঝারি) struct Shape { virtual double area() const = 0; }; — Shape s; লিখলে?

• s তৈরি হয়, area() ০ দেয়
• চলার সময় “pure virtual call” crash
• Compile error — abstract class-এর object বানানো যায় না
• = 0 লেখাটিই ব্যাকরণের ভুল

(সহজ) ফাংশনের শেষে override লেখার আসল সুবিধা কী?

• virtual ডাক দ্রুত হয়
• base class-এ মেলানো virtual ফাংশন না থাকলে compiler error দেয়
• derived class-এ আর override করা যায় না
• base-এর ফাংশনকে virtual বানিয়ে দেয়

(মাঝারি) ৬৪-বিট GCC-তে struct E {}; আর struct V { virtual void f(); }; — sizeof(E) আর sizeof(V) কত?

• ০ আর ০
• ১ আর ১
• ৮ আর ৮
• ১ আর ৮

(মাঝারি) SOLID-এর কোন নীতি বলে, base class যেখানে চলে, derived class-এর object সেখানে বসালেও প্রোগ্রাম ঠিক থাকতে হবে?

• Single Responsibility
• Open/Closed
• Liskov Substitution
• Dependency Inversion

(মাঝারি) template<typename T> T maxv(T a, T b); — maxv(3, 4.5) ডাকলে?

• T = double, ফল ৪.৫
• Compile error — T-এর দুটি ভিন্ন অনুমান
• T = int, ফল ৪
• Undefined behavior

(মাঝারি) template-এর পুরো সংজ্ঞা সাধারণত header ফাইলে রাখা হয় কেন?

• header-এ রাখলে প্রোগ্রাম দ্রুত চলে
• মানদণ্ড .cpp ফাইলে template নিষেধ করে
• linker template নিজে instantiate করে
• প্রতিটি ব্যবহারের জায়গায় compiler-এর পুরো সংজ্ঞা লাগে, instantiate করতে

(সহজ) std::map-এ find()-এর সময় কত?

• O(log n)
• O(1)
• O(n)
• O(n log n)

(মাঝারি) std::unordered_map-এ খোঁজার সময় কত?

• সব সময় O(1)
• সব সময় O(log n)
• গড়ে O(1), সবচেয়ে খারাপ ক্ষেত্রে O(n)
• O(n log n)

(মাঝারি) কোন container দুই প্রান্তেই দ্রুত (constant time) যোগ করতে দেয়, আবার [] দিয়ে সূচকেও পড়তে দেয়?

• std::vector
• std::deque
• std::list
• std::forward_list

(মাঝারি) std::list<int> l{3, 1, 2}; std::sort(l.begin(), l.end()); — কী হয়?

• l হয় 1 2 3
• চলার সময় crash
• Undefined behavior
• Compile error — list-এর iterator random access নয়

(কঠিন) auto it = v.begin(); v.push_back(4); std::cout << *it; — v একটি std::vector<int>. কোন কথাটি সঠিক?

• সব সময় প্রথম উপাদান ছাপে — নিরাপদ
• Compile error
• reallocation হলে it অচল — পড়া undefined behavior
• it নিজে থেকে নতুন প্রথম উপাদানে চলে যায়

(মাঝারি) std::map<std::string, int> m; if (m["x"] == 0) {} — এরপর m.size() কত?

• ০
• ১
• ২
• Compile error

(সহজ) std::set<int> s{3, 1, 3, 2}; for (int x : s) std::cout << x; — কী ছাপা হবে?

• 123
• 3132
• 1233
• 312

(কঠিন) std::vector<bool> vb{true}; bool& r = vb[0]; — কী হয়?

• r প্রথম উপাদানের reference হয়
• r-এ true-এর একটি কপি থাকে
• Undefined behavior
• Compile error — vb[0] একটি proxy ফেরত দেয়, bool& নয়

(মাঝারি) std::priority_queue<int> pq;-এ ৩, ১, ৪ push করলে pq.top() কত?

• ৩ — প্রথমে ঢোকানোটি
• ১ — সবচেয়ে ছোটটি
• ৪ — সবচেয়ে বড়টি
• ১ — শেষে ঢোকানোটি

(সহজ) std::accumulate কোন header-এ ঘোষিত?

• <algorithm>
• <functional>
• <numeric>
• <cmath>

(মাঝারি) সমান key-ওয়ালা উপাদানের আগের ক্রম রেখে সাজাতে চান। কোনটি এটি নিশ্চিত করে?

• std::sort
• std::stable_sort
• std::partial_sort
• std::nth_element

(মাঝারি) সাজানো v = {1, 3, 3, 5}. std::upper_bound(v.begin(), v.end(), 3) - v.begin() কত?

• ০
• ১
• ২
• ৩

(কঠিন) std::vector<int> v{1, 2, 1, 3}; std::remove(v.begin(), v.end(), 1); — এরপর v.size() কত?

• ৪
• ২
• ৩
• Compile error

(মাঝারি) কী ছাপা হবে?

int x = 1;
auto byVal = [x] { return x; };
auto byRef = [&x] { return x; };
x = 5;
std::cout << byVal() << byRef();

• 55
• 11
• 15
• 51

(মাঝারি) int x = 1; auto f = [x] { x++; }; — কী হয়?

• বাইরের x বাড়ে
• Compile error — value capture ডিফল্টে read-only
• শুধু lambda-র কপি বাড়ে, বাইরের x নয়
• Undefined behavior

(মাঝারি) for (int i : std::views::iota(1, 5)) std::cout << i; — কী ছাপা হবে?

• 1234
• 12345
• 01234
• Compile error

(মাঝারি) auto r = v | std::views::filter(isEven) | std::views::transform(sq); — isEven কখন ডাকা হয়?

• এই লাইনেই, সব উপাদানের জন্য একবার করে
• compile-এর সময়
• একটি নতুন vector তৈরির সময়, তার পরে আর নয়
• যখন r-এর ওপর লুপ চালিয়ে উপাদান পড়া হয়

(সহজ) std::vector<int> v{1, 2, 3, 4, 6};-এ std::count_if(v.begin(), v.end(), [](int k) { return k % 2 == 0; }) কত?

• ২
• ৩
• ৫
• ১২

(মাঝারি) std::move(x) নিজে আসলে কী করে?

• x-এর ডেটা নতুন জায়গায় সরিয়ে দেয়
• x-কে rvalue হিসেবে cast করে — সরানোর কাজ করে move constructor/assignment
• x-কে খালি করে দেয়
• x-এর মেমরি মুক্ত করে

(কঠিন) const std::string s = "hello"; std::string t = std::move(s); — কী ঘটে?

• নীরবে কপি হয় — s অক্ষত থাকে
• s থেকে move হয়, s খালি হয়
• Compile error
• Undefined behavior — const object বদলানো

(কঠিন) নিজের টাইপের move constructor-কে noexcept চিহ্নিত করা std::vector-এর জন্য কেন গুরুত্বপূর্ণ?

• noexcept ছাড়া vector-এ রাখাই যায় না
• noexcept দিলে move constructor-এর ভেতরের কোড দ্রুত চলে
• noexcept থাকলে vector নিজে exception ধরে
• reallocation-এ vector শুধু তখনই move করে, নয়তো কপি করে

(মাঝারি) C++11 থেকে একটি destructor-এর ভেতর থেকে exception বের হলে (বিশেষ কিছু না লিখলে) কী হয়?

• exception স্বাভাবিকভাবে caller-এর catch-এ যায়
• std::terminate — প্রোগ্রাম থেমে যায়
• Compile error
• exception নীরবে উপেক্ষা করা হয়

(মাঝারি) std::optional<int> o; (খালি) — o.value() আর *o সম্পর্কে কোনটি সঠিক?

• দুটিই ০ দেয়
• দুটিই exception ছোড়ে
• value() std::bad_optional_access ছোড়ে; *o undefined behavior
• দুটিই compile error

(সহজ) std::expected কোন মানদণ্ডে, কোন header-এ এসেছে?

• C++23, <expected>
• C++17, <optional>
• C++20, <utility>
• C++11, <exception>

(মাঝারি) std::variant<int, std::string> v = 5; std::get<std::string>(v); — কী হয়?

• "5" ফেরত দেয়
• খালি string ফেরত দেয়
• Compile error
• std::bad_variant_access ছোড়ে

(কঠিন) consteval int sq(int n) { return n * n; } — int k = 3; sq(k); লিখলে?

• চলার সময় হিসাব হয়ে ৯
• Compile error — ডাকটি constant expression নয়
• Undefined behavior
• compiler k-কে ৩ ধরে compile-এর সময়েই ৯ বসায়

(মাঝারি) template<std::integral T> T twice(T x); — twice(2.5) ডাকলে?

• 2.5 থেকে int-এ রূপান্তর করে ৪ দেয়
• ৫.০ দেয়
• Compile error — constraint সন্তুষ্ট হয়নি
• চলার সময় exception

(মাঝারি) INT_MAX ২১৪৭৪৮৩৬৪৭ ধরে, কোনটি undefined behavior?

• unsigned u = 0; u - 1;
• long long y = INT_MAX; y + 1;
• int z = 100; z * 2;
• int x = INT_MAX; x + 1;

(মাঝারি) তিন-মুখী তুলনা অপারেটর <=> (spaceship) কোন মানদণ্ডে এসেছে?

• C++11
• C++17
• C++20
• C++23

(সহজ) আগে থেকে লেখা আছে এমন log.txt-এ std::ofstream f("log.txt"); খুললে কী হয়?

• নতুন লেখা পুরোনোর শেষে যোগ হয়
• পুরোনো লেখা মুছে যায় (truncate)
• ফাইল খোলাই ব্যর্থ হয়
• ফাইলটি শুধু পড়ার জন্য খোলে

(মাঝারি) একটি std::thread object, যাতে join() বা detach() কোনোটিই ডাকা হয়নি, scope ছেড়ে ধ্বংস হলে কী হয়?

• std::terminate — প্রোগ্রাম থেমে যায়
• destructor নিজে join করে অপেক্ষা করে
• thread নিজে থেকে detach হয়ে চলতে থাকে
• Compile error

(মাঝারি) দুটি thread কোনো lock ছাড়া একই int counter-এ ১০ লাখবার করে ++counter করে। ফল সম্পর্কে কোনটি সঠিক?

• সব সময় ঠিক ২০ লাখ
• সব সময় ২০ লাখের কম — নির্ধারিত আচরণ
• Compile error
• Data race — undefined behavior

(কঠিন) Thread ১ আগে m1, পরে m2 lock করে; thread ২ আগে m2, পরে m1. কী বিপদ, আর C++17-এর সহজ সমাধান কী?

• Data race; সমাধান volatile
• Spurious wakeup; সমাধান predicate
• Deadlock; সমাধান std::scoped_lock(m1, m2)
• Memory leak; সমাধান std::atomic

(মাঝারি) std::condition_variable-এর wait সাধারণত একটি শর্ত (predicate) দিয়ে ডাকা হয় — cv.wait(lk, [&]{ return ready; }); — কেন?

• predicate দিলে wait দ্রুত হয়
• Spurious wakeup — কারণ ছাড়াই জাগলে শর্ত আবার যাচাই করতে
• predicate ছাড়া compile হয় না
• predicate না দিলে mutex ছাড়া হয় না

(সহজ) CMake-এ main.cpp থেকে app নামের প্রোগ্রাম বানানোর লক্ষ্য (target) কোন কমান্ড ঘোষণা করে?

• add_executable(app main.cpp)
• add_library(app main.cpp)
• target_link_libraries(app main.cpp)
• project(app main.cpp)

(মাঝারি) দুই thread-এর data race খুঁজতে GCC/Clang-এর কোন flag দরকার?

• -fsanitize=address
• -fsanitize=undefined
• -Wall -Wextra
• -fsanitize=thread

(মাঝারি) ১০ লাখ int-এর ওপর লুপ চালালে std::vector সাধারণত std::list-এর চেয়ে অনেক দ্রুত কেন — যদিও দুটিই O(n)?

• vector-এর লুপ O(log n)
• পাশাপাশি মেমরি — cache locality
• compiler vector-এর লুপ মুছে দেয়
• list-এর প্রতিটি ধাপে সূচক হিসাব করতে হয়

(মাঝারি) int a = 100000, b = 100000; long long c = a * b; — c-তে কী থাকে?

• ১০০০০০০০০০০ (১০^১০)
• নিশ্চিতভাবে ১৪১০০৬৫৪০৮
• Compile error
• Undefined behavior — int-এ গুণ overflow করে

(মাঝারি) কনটেস্টে std::ios::sync_with_stdio(false); std::cin.tie(nullptr); লেখার পরে কোনটি এড়াতে হবে?

• একই প্রোগ্রামে cout আর printf মেশানো
• '\n' দিয়ে নতুন লাইন লেখা
• বড় ইনপুট পড়া
• long long পড়া