The Most Impactful C++ interview questions

class Singleton {
private:
    static std::once_flag initialized;
    static std::unique_ptr<Singleton> instance;
    Singleton() = default;
public:
    static Singleton& getInstance() {
        std::call_once(initialized, []() {
            instance = std::make_unique<Singleton>

62. Write a custom smart pointer implementation.
Expected Implementation:
template<typename T>
class UniquePtr {
private:
    T* ptr;
public:
    explicit UniquePtr(T* p = nullptr) : ptr(p) {}
    ~UniquePtr() { delete ptr; }
    
    UniquePtr(const UniquePtr&) = delete;
    UniquePtr& operator=(const UniquePtr&) = delete;
    
    UniquePtr(UniquePtr&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }
    
    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }
    T* get() const { return ptr; }
    T* release() {
        T* temp = ptr;
        ptr = nullptr;
        return temp;
    }
};

template<typename T>
class Stack {
private:
    std::vector<T> data;
public:
    void push(const T& item) {
        data.push_back(item);
    }
    
    void push(T&& item) {
        data.push_back(std::move(item));
    }
    
    T pop() {
        if (data.empty()) {
            throw std::runtime_error("Stack is empty");
        }
        T result = std::move(data.back());
        data.pop_back();
        return result;
    }
    
    bool empty() const { return data.empty(); }
    size_t size() const { return data.size(); }
};

template<typename T>
class ThreadSafeQueue {
private:
    mutable std::mutex mtx;
    std::queue<T> data;
    std::condition_variable cv;
public:
    void push(T item) {
        std::lock_guard<std::mutex> lock(mtx);
        data.push(std::move(item));
        cv.notify_one();
    }
    
    bool tryPop(T& item) {
        std::lock_guard<std::mutex> lock(mtx);
        if (data.empty()) return false;
        item = std::move(data.front());
        data.pop();
        return true;
    }
    
    void waitAndPop(T& item) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this] { return !data.empty(); });
        item = std::move(data.front());
        data.pop();
    }
    
    bool empty() const {
        std::lock_guard<std::mutex>

class MemoryPool {
private:
    struct Block {
        Block* next;
    };
    
    Block* freeBlocks;
    std::vector<std::unique_ptr<char[]>> chunks;
    size_t blockSize;
    size_t blocksPerChunk;
public:
    MemoryPool(size_t blockSize, size_t blocksPerChunk = 1024)
        : freeBlocks(nullptr), blockSize(blockSize), 
          blocksPerChunk(blocksPerChunk) {
        allocateChunk();
    }
    
    void* allocate() {
        if (!freeBlocks) allocateChunk();
        Block* block = freeBlocks;
        freeBlocks = freeBlocks->next;
        return block;
    }
    
    void deallocate(void* ptr) {
        Block* block = static_cast<Block*>(ptr);
        block->next = freeBlocks;
        freeBlocks = block;
    }
private:
    void allocateChunk() {
        auto chunk = std::make_unique<char[]>(blockSize * blocksPerChunk);
        char* start = chunk.get();
        
        for (size_t i = 0; i < blocksPerChunk - 1; ++i) {
            Block* block = reinterpret_cast<Block*>(start + i * blockSize);
            block->next = reinterpret_cast<Block*>(start + (i + 1) * blockSize);
        }
        
        Block* lastBlock = reinterpret_cast<Block*>(start + (blocksPerChunk - 1) * blockSize);
        lastBlock->next = freeBlocks;
        freeBlocks = reinterpret_cast<Block*>(start);
        
        chunks.push_back(std::move(chunk));
    }
};