Basics of C++

C++ is a general-purpose, multi-paradigm programming language with a rich feature set that has grown substantially through C++11, C++14, C++17, C++20, and C++23. Key features interviewers expect you to know:

1. Object-oriented programming (OOP): C++ supports classes, objects, inheritance, polymorphism, and encapsulation. This allows for modular, reusable code design.

2. Multi-paradigm support: C++ supports procedural, object-oriented, generic, and functional programming styles — often within the same program.

3. Strong static typing: Variables must be declared with explicit types. Implicit type conversions are narrowed; unsafe conversions require explicit casts (static_cast, reinterpret_cast, etc.).

4. Templates and generic programming: Function and class templates allow type-independent code. Template metaprogramming enables compile-time computation. C++20 adds Concepts to constrain template parameters with readable, compiler-enforced predicates.

5. Standard Template Library (STL): A comprehensive library of containers (vector, map, unordered_map, etc.), iterators, and algorithms. C++20 introduces the Ranges library, which enables composable, lazy pipeline-style algorithm chains.

6. Memory management and RAII: C++ gives direct control over memory via new/delete and pointers, but modern C++ strongly favors RAII and smart pointers (std::unique_ptr, std::shared_ptr) to prevent leaks. Manual new/delete is considered a code smell in new code.

7. Move semantics and rvalue references (C++11+): Enables efficient transfer of resources without copying. Foundational to writing performant modern C++.

8. Exception handling: try/catch/throw provide structured error propagation. noexcept specifies that a function will not throw, enabling compiler optimizations.

9. Concurrency support: C++11 introduced std::thread, mutexes, and condition variables. C++17 added parallel algorithms. C++20 adds coroutines (co_await, co_yield, co_return) and std::jthread.

10. Modern additions (C++20/23):

    • Modules: Replace #include with import for faster builds and better encapsulation.
    • std::format / std::print: Type-safe, Python-style string formatting (C++20/23), replacing printf and stringstream hacks.
    • std::span: A non-owning view over contiguous data, replacing raw pointer + size pairs.
    • Three-way comparison (<=>): The "spaceship operator" auto-generates all six comparison operators.

11. Low-level access: C++ retains C's ability to work directly with hardware — pointers, raw memory, bit manipulation — making it suitable for systems programming, embedded, and game development.

Common follow-up: "What would you choose C++ over other languages for?" — Performance-critical applications, systems/embedded programming, game engines, or any domain where you need both high-level abstractions and low-level control.

C++ is a superset of C (with a small number of deliberate incompatibilities), but the two languages have diverged significantly in idiom and capability. Key differences:

1. Object-Oriented Programming: C++ adds classes, objects, inheritance, polymorphism, and encapsulation. C has only structs (no methods, no access control).

2. Templates and generic programming: C++ templates allow type-generic containers and algorithms at compile time. C relies on void* or macros for generics, which sacrifice type safety.

3. Function and operator overloading: C++ allows multiple functions with the same name differing by parameter types. C does not support overloading.

4. References: C++ adds reference types (int&), providing a safer alternative to pointers for aliasing. C only has pointers.

5. Exception handling: C++ has built-in try/catch/throw. C uses error codes and setjmp/longjmp (which are fragile).

6. Standard Template Library (STL): C++ ships with a rich library of containers, iterators, and algorithms. C's standard library is much smaller and lower-level.

7. Namespaces: C++ namespaces prevent naming collisions across large codebases. C has a single global namespace.

8. Memory management: Both support malloc/free, but C++ adds new/delete and, crucially, smart pointers (std::unique_ptr, std::shared_ptr) and RAII for safe, automatic resource management.

9. bool type: C++ has a native bool. C89 lacks one (C99 added _Bool/stdbool.h).

10. const semantics: In C++, const variables have internal linkage by default and are truly compile-time constants when used correctly. C's const is weaker and does not create compile-time constants usable in array sizes (without VLAs).

11. Modern C++ additions (C++11–C++23): Move semantics, lambdas, auto type deduction, range-based for, coroutines, modules, concepts, std::format — none of these exist in C.

Key gotcha interviewers probe: C and C++ are not fully compatible. For example, C++ is stricter about void* conversions (must cast explicitly), inline has different semantics, and C99/C11 features like variable-length arrays (VLAs) and designated initializers were not in C++ until C++20. When asked about interoperability, mention extern "C" for calling C code from C++ (disables name mangling).

The main function is the mandatory entry point of every C++ program — execution begins here after global object construction and ends when main returns (or std::exit is called).

Standard signatures:

int main()                            // no command-line arguments
int main(int argc, char* argv[])      // command-line arguments
int main(int argc, char* argv[], char* envp[])  // + environment (platform extension)

The return type must be int. Returning 0 (or falling off the end of main — unique among C++ functions) signals success to the OS. Any non-zero value signals failure; portable programs use EXIT_SUCCESS and EXIT_FAILURE from ``.

Key points interviewers ask about:

• Only one main per program. It cannot be overloaded, called recursively (technically undefined behaviour), or taken by address.
• argc and argv: argc is the count of arguments (at least 1, since argv[0] is conventionally the program name). argv[argc] is guaranteed to be nullptr.
• Global constructors run before main. If a global object's constructor throws, main is never reached. This is why heavy logic in global constructors is a code smell.
• Destructors of local objects in main run on normal return. std::exit() does not call them, which can skip RAII cleanup — use std::atexit or prefer normal return.
• WinMain / wmain (Windows): Windows GUI programs use WinMain as the OS entry point, but the C++ runtime still calls the standard main behind the scenes in many frameworks.

Common follow-up: "What happens before main is called?" — The C++ runtime initialises static-duration objects with non-trivial constructors (in translation-unit order, which is unspecified across TUs — the "static initialisation order fiasco"), then calls main.

In C++, variables are declared by writing the type followed by the variable name. Initialization can happen in several forms, and modern C++ strongly prefers uniform (brace) initialization introduced in C++11.

Forms of initialization:

// Copy initialization (C-style)
int a = 5;

// Direct initialization
int b(10);

// Uniform (brace) initialization — preferred in modern C++ (C++11+)
int c{15};           // prevents narrowing conversions — compiler error if value doesn't fit
double d{3.14};

// Default initialization (uninitialized — undefined value for built-ins)
int e;               // dangerous: holds garbage; always initialize

// Value initialization (zero-initializes built-in types)
int f{};             // f == 0
double g{};          // g == 0.0

// auto type deduction (C++11+)
auto h = 42;         // int
auto i = 3.14;       // double
auto j = "hello"s;   // std::string (with using namespace std::string_literals)

Key points interviewers probe:

• Narrowing conversions: Brace initialization {} is the only form that makes narrowing a compile-time error. int x{3.7}; won't compile; int x = 3.7; silently truncates.
• const and constexpr: const marks a variable as read-only. constexpr (C++11) means the value must be known at compile time and can appear in constant expressions (array sizes, template arguments, etc.).

const int maxSize = 100;         // runtime const
constexpr int bufferSize = 256;  // compile-time constant

• auto: Let the compiler deduce the type. Particularly useful with complex iterator types or lambda return types. Use const auto& to avoid unintended copies when iterating.
• Structured bindings (C++17): Destructure aggregates, pairs, and tuples directly.

auto [key, value] = std::make_pair(1, "one");

• std::optional (C++17): For variables that may or may not hold a value, prefer std::optional over sentinel values like -1 or nullptr.

Best practice: Always initialize variables at the point of declaration. Uninitialized built-in type variables contain indeterminate values — reading them is undefined behaviour.

C++ provides three classic loop constructs plus a modern range-based form:

1. for loop — use when the iteration count or range bounds are known up front.

for (int i = 0; i < 10; ++i) {
    std::cout << i << '\n';
}

2. Range-based for loop (C++11+) — the preferred way to iterate over any range (array, container, or anything providing begin()/end()). Use const auto& to avoid copies.

std::vector v{1, 2, 3, 4, 5};
for (const auto& x : v) {
    std::cout << x << '\n';
}

With C++20 Ranges you can also iterate lazily over transformed or filtered views without copying:

for (auto x : v | std::views::filter([](int n){ return n % 2 == 0; })) {
    std::cout << x << '\n';
}

3. while loop — use when the loop should continue as long as a condition is true and the number of iterations is not known in advance.

int n = 1;
while (n < 100) {
    n *= 2;
}

4. do-while loop — guarantees the body executes at least once before the condition is checked.

int choice;
do {
    std::cout << "Enter a positive number: ";
    std::cin >> choice;
} while (choice <= 0);

Loop control statements:

Common interview gotchas:

• Prefer ++i over i++ for non-trivial iterators (avoids creating a temporary copy).
• Infinite loops: for (;;) or while (true) are idiomatic; always have a reachable break or return.
• Range-based for with auto (not auto&) copies each element — a silent performance bug for large objects.