C++ Interview Prep: Core Language Concepts

int x = 42;          // x is an lvalue — has identity (address), lives beyond expression
int* p = &x;         // OK: x is addressable

42 + 1;              // prvalue — pure temporary, no identity
int&& r = 42;        // prvalue materializes into xvalue when bound to r

std::string s = "hello";
std::string&& rv = std::move(s);  // std::move casts s to xvalue (expiring lvalue)
// s is still "alive" — it's just been told it can be moved from

// Key rule: a NAMED rvalue reference IS an lvalue
void f(std::string&& s) {
    // s is an lvalue here! It has a name.
    g(s);             // calls g(const string&) — copies
    g(std::move(s));  // explicitly cast to xvalue — moves
}

class Buffer {
    std::byte* data_;
    std::size_t size_;

public:
    Buffer(Buffer&& other) noexcept    // without noexcept: vector copies instead of moving!
        : data_(other.data_), size_(other.size_)
    {
        other.data_ = nullptr;
        other.size_ = 0;
    }

    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            data_      = other.data_;
            size_      = other.size_;
            other.data_ = nullptr;
            other.size_ = 0;
        }
        return *this;
    }
};

// Why it matters:
std::vector<Buffer> v;
v.push_back(Buffer{...});   // if push_back triggers reallocation and
                             // move constructor is NOT noexcept,
                             // vector falls back to copy for strong exception guarantee

// Rule of Zero — preferred: let the compiler handle everything
class Config {
    std::string path_;       // std::string handles its own copying/moving
    std::vector<int> data_;  // std::vector handles its own copying/moving
    // No destructor, no copy/move constructors needed — they're all generated correctly
};

// Rule of Five — required when you manage raw resources
class RawBuffer {
    char* ptr_;
    std::size_t size_;

public:
    ~RawBuffer()                              { delete[] ptr_; }
    RawBuffer(const RawBuffer& o)             : ptr_(new char[o.size_]), size_(o.size_)
                                              { std::copy(o.ptr_, o.ptr_ + size_, ptr_); }
    RawBuffer& operator=(const RawBuffer& o)  { RawBuffer tmp{o}; swap(tmp); return *this; }
    RawBuffer(RawBuffer&& o) noexcept         : ptr_(o.ptr_), size_(o.size_)
                                              { o.ptr_ = nullptr; o.size_ = 0; }
    RawBuffer& operator=(RawBuffer&& o) noexcept {
        swap(o);   // give o our old data (it will destroy it)
        return *this;
    }
    void swap(RawBuffer& o) noexcept {
        std::swap(ptr_, o.ptr_);
        std::swap(size_, o.size_);
    }
};

// RAII = tie a resource's lifetime to an object's lifetime
// Acquisition in constructor, release in destructor, guaranteed by stack unwinding

// Example: database transaction
class Transaction {
    Database& db_;
    bool committed_ = false;

public:
    explicit Transaction(Database& db) : db_(db) { db_.begin(); }

    void commit() { db_.commit(); committed_ = true; }

    ~Transaction() noexcept {
        if (!committed_) {   // rollback if commit was never called
            try { db_.rollback(); }
            catch (...) {}   // destructors must never throw
        }
    }

    Transaction(const Transaction&) = delete;
    Transaction& operator=(const Transaction&) = delete;
};

void transfer(Database& db, int from, int to, int amount) {
    Transaction txn{db};
    db.debit(from, amount);
    db.credit(to, amount);  // if this throws, ~Transaction() rolls back automatically
    txn.commit();
}

struct Base {
    virtual void f() {}
    // NO virtual destructor — this is wrong for polymorphic base classes!
};

struct Derived : Base {
    std::string data{"expensive string"};
    ~Derived() { /* clean up data */ }
};

Base* p = new Derived;
delete p;   // UB: calls Base::~Base() only, Derived::~Derived() never called
            // data is leaked; undefined behavior

// Fix:
struct CorrectBase {
    virtual void f() {}
    virtual ~CorrectBase() = default;   // virtual destructor
};

void print(Base b) {   // takes by VALUE — slices!
    b.f();             // calls Base::f() even if passed a Derived
}

Derived d;
print(d);   // d is sliced to Base — Derived portion discarded

// Fix: always use pointer or reference for polymorphism
void print(const Base& b) { b.f(); }   // calls Derived::f() correctly

struct Base {
    virtual void process(int x) {}
};

struct Wrong : Base {
    void process(long x) {}         // silently hides, doesn't override (different signature)
};

struct Correct : Base {
    void process(int x) override {} // compiler error if signature doesn't match
};

class Cache {
    mutable std::unordered_map<int, Result> cache_;  // mutable: modified in const method
    mutable std::mutex mutex_;                        // mutable: locked in const method

public:
    // Conceptually const — doesn't change the observable state of the object
    Result get(int key) const {
        std::lock_guard lock{mutex_};
        auto it = cache_.find(key);
        if (it != cache_.end()) return it->second;

        auto result = expensive_compute(key);
        cache_[key] = result;   // OK: cache_ is mutable
        return result;
    }
};

int x = 10, y = 20;

const int* p1 = &x;   // pointer to const int: can't modify *p1, can change p1
p1 = &y;              // OK
// *p1 = 30;          // error

int* const p2 = &x;   // const pointer to int: can modify *p2, can't change p2
*p2 = 30;             // OK
// p2 = &y;           // error

const int* const p3 = &x;  // both const

Widget w(Foo());   // NOT construction — parses as function declaration!
                   // Declares function w that returns Widget and takes Foo(*)(void)

Widget w{Foo{}};   // fix: uniform initialization
Widget w((Foo())); // fix: extra parens (ugly)

int x = INT_MAX;
x + 1;   // UB! signed integer overflow is undefined in C++
          // compiler may assume it never happens and optimize accordingly

unsigned u = UINT_MAX;
u + 1;   // defined: wraps to 0 (unsigned overflow is well-defined)

// Pre-C++17: evaluation order of arguments is unspecified
f(++i, i);   // UB: reads and modifies i in the same expression (before C++17)
             // C++17 tightened some rules but not all

// Safe pattern: use separate statements
++i;
f(i, i);

Base* b = new Derived;

auto* d1 = static_cast<Derived*>(b);   // no runtime check — UB if b isn't Derived
auto* d2 = dynamic_cast<Derived*>(b);  // runtime check — returns nullptr if fails

// dynamic_cast requires a virtual function in Base (for RTTI)
// static_cast preferred when you know the type; dynamic_cast for checked downcasts

int   x = 10;       // x  is an lvalue (glvalue): has identity, not expiring
int&& r = 42;       // 42 is a prvalue: no identity; materializes into a temporary

std::string s = "hello";
std::string&& rv = std::move(s);
// std::move(s) returns string&&, which is an xvalue:
//   — it still refers to a real object (has identity)
//   — but signals "you may steal my resources"

// Materialization: a prvalue materializes into an xvalue when bound to a reference
// or when a member is accessed from a class prvalue.
const std::string& r2 = std::string("world");  // prvalue materializes; lifetime extended

// The named-rvalue trap:
void sink(std::string&& s) {
    // s is an LVALUE here — it has a name!
    use(s);             // copies — you lost the move
    use(std::move(s));  // explicit move — correct
}

// Classic 1: signed overflow
int i = INT_MAX;
if (i + 1 < 0) {           // UB: signed overflow
    std::cout << "negative\n";
}
// GCC with -O2 may eliminate the branch entirely (it "knows" overflow can't happen)
// The "safe" fix:
if (i < INT_MAX) { /* OK to increment */ }

// Classic 2: strict aliasing
float f = 1.0f;
int*  p = reinterpret_cast<int*>(&f);  // UB: accessing float through int*
std::cout << *p;
// Allowed alternative: memcpy or std::bit_cast<int>(f) (C++20)
int bits;
std::memcpy(&bits, &f, sizeof(bits));  // defined: copies bytes, no aliasing

// Classic 3: reading an indeterminate value
int x;            // uninitialized local — indeterminate value
std::cout << x;   // UB: use of indeterminate value (even though it "usually prints 0")

// Classic 4: dangling reference
int& bad_ref() {
    int local = 42;
    return local;   // returning reference to stack variable — UB to use the return value
}

// Classic 5: null dereference
int* ptr = nullptr;
std::cout << *ptr;   // UB — even though it "always segfaults in practice"

struct Animal {
    virtual void speak() { std::cout << "...\n"; }
    virtual ~Animal() = default;
    // Hidden member (conceptually): Animal_vtable* vptr;
};

struct Dog : Animal {
    void speak() override { std::cout << "Woof\n"; }
};

struct Cat : Animal {
    void speak() override { std::cout << "Meow\n"; }
};

// At runtime:
Animal* a = new Dog;
a->speak();  // → load a->vptr, fetch vptr[speak_slot], call it → "Woof"

// Cost breakdown:
// 1. Dereference a        (may miss cache — random heap pointer)
// 2. Load vptr            (first 8 bytes of object — usually hot)
// 3. Load function ptr    (vtable slot — often hot if few derived types)
// 4. Indirect call        (branch predictor may succeed if the same type each time)

// Devirtualization: compiler can eliminate the overhead when it can prove the type
Dog d;
d.speak();   // compiler knows static type is Dog → direct call, zero virtual overhead

// final eliminates virtual overhead for further derivation:
struct FastDog final : Animal {
    void speak() override { std::cout << "Woof\n"; }
};
// No class can derive from FastDog, so calls through FastDog* can be devirtualized

Animal* a = new Dog;

// dynamic_cast: runtime type check using RTTI stored alongside vtable
Dog* d = dynamic_cast<Dog*>(a);   // returns non-null — a really is a Dog
Cat* c = dynamic_cast<Cat*>(a);   // returns nullptr — a is not a Cat

// Requirements:
// — Base class must have at least one virtual function (enables RTTI)
// — Compile with RTTI enabled (default; -fno-rtti disables it)

// dynamic_cast for references: throws std::bad_cast instead of returning null
try {
    Dog& dref = dynamic_cast<Dog&>(*a);   // OK
    Cat& cref = dynamic_cast<Cat&>(*a);   // throws std::bad_cast
} catch (const std::bad_cast& e) { }

// Cost: O(depth of inheritance hierarchy), not O(1) — avoid in hot paths
// Alternative when hierarchy is known: static_cast (no check, zero cost)
Dog* d2 = static_cast<Dog*>(a);   // UB if a is not actually a Dog

// Compiler generates all six if you declare nothing:
struct Simple {
    int x;
    // default ctor, copy ctor, copy=, move ctor, move=, destructor: all generated
};

// Declaring a destructor: suppresses move constructor and move assignment!
struct Logged {
    ~Logged() { std::cout << "destroyed\n"; }
    // copy ctor and copy= are still generated (deprecated, but generated)
    // move ctor and move= are NOT generated → falls back to copy everywhere
};

// Fix: explicitly default the move operations
struct LoggedFixed {
    ~LoggedFixed() { std::cout << "destroyed\n"; }
    LoggedFixed(LoggedFixed&&) noexcept = default;
    LoggedFixed& operator=(LoggedFixed&&) noexcept = default;
};

// Declaring any constructor suppresses the default constructor:
struct HasCustomCtor {
    HasCustomCtor(int x) {}
    // No default constructor!
    // HasCustomCtor hcc;  // ERROR: no default constructor
};

// The full suppression table (simplified):
// User declares →              | default ctor | copy ctor | copy= | move ctor | move= | dtor
// nothing                      | gen          | gen       | gen   | gen       | gen   | gen
// any constructor              | NOT gen      | gen       | gen   | gen       | gen   | gen
// copy ctor                    | NOT gen      | user      | gen   | NOT gen   | NOT gen | gen
// copy=                        | gen          | gen       | user  | NOT gen   | NOT gen | gen
// move ctor                    | NOT gen      | =delete   | =delete | user   | NOT gen | gen
// move=                        | NOT gen      | =delete   | =delete | NOT gen | user  | gen
// destructor                   | gen          | gen       | gen   | NOT gen   | NOT gen | user

// Practical advice: if you declare any of the five, declare all five (Rule of Five)
// or declare none and use RAII member types (Rule of Zero)
struct SafeResource {
    std::unique_ptr<int[]> data;   // Rule of Zero — unique_ptr handles everything
    // No need to declare any special member
};