C++ Interview Questions and Answers

Templates parameterise code by type and are instantiated at compile time, giving zero-cost abstraction.

template <typename T>
T maxOf(T a, T b) { return a > b ? a : b; }

template <>
const char* maxOf<const char*>(const char* a, const char* b) {
    return std::strcmp(a, b) > 0 ? a : b; // explicit specialization
}

Variadic templates and fold expressions handle arbitrary argument counts. C++20 concepts constrain templates and produce readable diagnostics:

template <typename T> requires std::integral<T>
T twice(T x) { return x + x; }

Template definitions usually live in headers because the compiler needs them at instantiation. The downsides are longer compile times, code bloat and historically terrible error messages. auto and decltype help deduction, while static_assert turns assumptions into clear compile-time checks. Prefer concepts over SFINAE for readability in modern code.

The rule of three: if a class needs a custom destructor, copy constructor or copy assignment operator, it probably needs all three, because they manage the same resource. The compiler-generated copy does a shallow member-wise copy, so forgetting one causes double frees or leaks.

class Buf {
public:
    ~Buf();                              // frees
    Buf(const Buf&);                     // deep copy
    Buf& operator=(const Buf&);
    Buf(Buf&&) noexcept;                 // C++11 additions
    Buf& operator=(Buf&&) noexcept;
};

The rule of five extends this to the move operations for efficiency. The rule of zero says the best design needs none of them: store resources in RAII members such as std::vector or unique_ptr and let the compiler generate correct operations.

Undefined behaviour means the standard imposes no requirements, so out-of-bounds access, use-after-free, signed overflow and data races let the optimiser do surprising things. Detect it with -Wall -Wextra, AddressSanitizer, UBSan and Valgrind rather than guessing.