Master C/C++ Interview Essentials: Key Concepts, Code Samples & Tips

1. C/C++ Language Basics High‑Frequency Questions

1.1 Variables and Memory

Question: Discuss the difference between procedural and object‑oriented programming.

Procedural programming focuses on functions and steps, keeping data separate from functions, while object‑oriented programming (OOP) encapsulates data and behavior within objects, emphasizing abstraction, encapsulation, inheritance, and polymorphism.

Key differences:

Abstraction level – procedures vs. objects.

Data encapsulation – separate vs. bundled.

Inheritance and polymorphism – absent in procedural, core to OOP.

Code reuse – modular functions vs. class inheritance/composition.

Choice depends on project size and requirements; large projects often benefit from OOP for maintainability.

Question: What is the purpose of the static keyword?

Static variables inside functions retain their value across calls; static functions have internal linkage; static global variables are limited to the translation unit; static class members belong to the class itself.

void increment() {
    static int counter = 0;
    ++counter;
    std::cout << "Counter: " << counter << std::endl;
}

int main() {
    increment(); // Counter: 1
    increment(); // Counter: 2
    increment(); // Counter: 3
    return 0;
}

Static member function example:

static void internalFunction() {
    std::cout << "This is an internal function." << std::endl;
}

int main() {
    internalFunction();
    return 0;
}

Static class member example:

class MyClass {
public:
    static int count;
    static void increaseCount() {
        ++count;
        std::cout << "Count: " << count << std::endl;
    }
};
int MyClass::count = 0;

int main() {
    MyClass::increaseCount(); // Count: 1
    MyClass::increaseCount(); // Count: 2
    return 0;
}

1.2 Keywords and Operators

Question: What does the const keyword do?

It declares constants, makes function parameters read‑only, and can mark member functions as non‑modifying. const int MAX_VALUE = 100; Example of a const member function:

class MyClass {
public:
    void printValue() const { std::cout << value << std::endl; }
private:
    int value;
};

Question: Difference between Java’s synchronized and C++ volatile?

C++ has no direct synchronized; synchronization is achieved with mutexes. volatile tells the compiler not to optimize accesses to a variable, useful for hardware registers or signal handlers, but does not provide atomicity or ordering guarantees.

1.3 Memory Management

Question: Where does memory allocated with new reside?

On the heap. Stack memory is used for local variables and function parameters.

Question: Why is stack allocation faster than heap allocation?

Stack allocation is a simple pointer move (LIFO), while heap allocation requires searching free blocks, possible fragmentation handling, and may involve system calls.

Question: What are common heap memory leak scenarios?

Forgetting to delete or free heap‑allocated memory, especially when pointers go out of scope without ownership transfer.

Question: How to reduce heap‑management risks in C++?

Use smart pointers ( std::unique_ptr, std::shared_ptr), follow RAII principles, or employ memory pools.

2. Data Structures and Algorithms Common Questions

2.1 Common Data Structures

Question: Differences between arrays and linked lists.

Arrays store elements contiguously, offering O(1) random access but costly O(n) insert/delete.

Linked lists store nodes non‑contiguously, providing O(1) insert/delete given a node reference but O(n) access.

Question: Characteristics and use‑cases of stacks and queues.

Stack – LIFO; used for function call stacks, expression evaluation, DFS.

Queue – FIFO; used for task scheduling, message queues, BFS.

2.2 Classic Sorting Algorithms

Question: Quick sort principle and implementation.

Quick sort uses divide‑and‑conquer: choose a pivot, partition the array, then recursively sort sub‑arrays.

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; ++j) {
        if (arr[j] < pivot) {
            ++i;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[i + 1], arr[high]);
    return i + 1;
}

Average time O(n log n), worst‑case O(n²), space O(log n).

Question: Bubble sort principle and optimization.

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        bool swapped = false;
        for (int j = 0; j < n - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
                swapped = true;
            }
        }
        if (!swapped) break; // early exit if already sorted
    }
}

Time O(n²) average/worst, O(n) best with early exit; space O(1).

2.3 Algorithmic Thinking

Question: Binary search usage and implementation.

int binarySearch(int arr[], int left, int right, int target) {
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) return mid;
        else if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

Time O(log n), space O(1).

Question: General steps of dynamic programming.

Identify optimal substructure.

Define state representation.

Derive state transition recurrence.

Initialize base cases.

Iteratively compute or recursively memoize to obtain final answer.

3. Object‑Oriented Programming (OOP) Topics

3.1 OOP Characteristics

Encapsulation: Bundles data and methods, hides internal details, provides public interfaces (e.g., a BankAccount class with private balance and public deposit / withdraw).

Benefits: improves security, maintainability, and reduces coupling.

Inheritance: Enables a derived class to reuse and extend a base class (e.g., Student inherits from Person).

Types: public, protected, private inheritance; access control via public, protected, private members.

Diamond inheritance problem: Multiple paths to a common base cause duplicate sub‑objects and ambiguity; solved with virtual inheritance ( class B : virtual public A).

Composition vs. Inheritance: Use inheritance for “is‑a” relationships, composition for “has‑a” relationships to reduce coupling.

3.2 Polymorphism

Implemented via virtual functions. Base class declares virtual methods; derived classes override them. Calls through base‑class pointers/reference resolve at runtime.

class Base {
public:
    virtual void func() { std::cout << "Base" << std::endl; }
};

class Derived : public Base {
public:
    void func() override { std::cout << "Derived" << std::endl; }
};

Base* ptr = new Derived();
ptr->func(); // prints "Derived"

Pure virtual functions ( = 0) make a class abstract; such classes cannot be instantiated and serve as interfaces.

Virtual destructors ensure proper cleanup when deleting through a base‑class pointer.

3.3 Special Member Functions

Copy constructor: ClassName(const ClassName&) – performs shallow copy by default; customize for deep copy when class owns resources.

Move constructor: ClassName(ClassName&&) – transfers ownership of resources from an r‑value, avoiding expensive copies.

Assignment operator: Handles self‑assignment, releases existing resources, then copies or moves.

Rule of Three/Five: if a class defines one of destructor, copy constructor, or copy assignment, it likely needs to define all three (or five with move semantics).

Delete unwanted copy/move operations with = delete to enforce non‑copyable semantics (e.g., singletons).

3.4 Templates and Generic Programming

Templates enable type‑independent code.

Function template example:

template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

Class template example:

template <typename T>
class Stack {
private:
    std::vector<T> elems;
public:
    void push(const T& val) { elems.push_back(val); }
    void pop() { elems.pop_back(); }
    T& top() { return elems.back(); }
};

Template specialization provides custom implementations for specific types, and SFINAE ( std::enable_if) allows compile‑time constraints.

Since C++11, variadic templates, alias templates ( using), and constexpr functions enhance generic programming.

Overall, mastering these C/C++ fundamentals, data structures, algorithms, OOP concepts, and template techniques equips candidates to excel in technical interviews across entry‑level and experienced positions.