Ace Your C++ Interview: Top 25+ Must-Know Q&A | Your Personal AI Help

Stack Memory:

• Used for static memory allocation.
• Managed automatically by the compiler.
• Limited in size.
• Fast access.
• Memory is deallocated when the function call ends.

Heap Memory:

• Used for dynamic memory allocation.
• Managed manually by the programmer.
• Larger in size compared to stack.
• Slower access.
• Memory must be explicitly deallocated using delete or free .

The this pointer is an implicit pointer available in non-static member functions of a class. It points to the object for which the member function is called. It is used to access members of the object within the member functions and to distinguish between member variables and parameters with the same name.

Example:

class MyClass {
    int value;
public:
    void setValue(int value) {
        this->value = value; // 'this->value' refers to the member variable, 'value' refers to the parameter
    }
};

Friend Function: A friend function is a function that is not a member of a class but has access to its private and protected members. It is declared using the friend keyword inside the class.

Friend Class: A friend class is a class that can access the private and protected members of another class in which it is declared as a friend.

Example of friend function:

class MyClass {
private:
    int secret;
public:
    MyClass(int s) : secret(s) {}
    friend void revealSecret(const MyClass& obj);
};

void revealSecret(const MyClass& obj) {
    std::cout << obj.secret << std::endl;
}

Function Overloading:

• Allows multiple functions with the same name but different parameters within the same scope.
• The compiler differentiates them based on the number or type of parameters.

Function Overriding:

• Allows a derived class to provide a specific implementation of a function that is already defined in its base class.
• Requires the base function to be virtual.
• The signature of the overriding function must be the same as that of the base class function.

Example of overloading:

class Example {
public:
    void func(int x) {}
    void func(double x) {}
    void func(int x, double y) {}
};

Const Member Functions:

• Declared with the const keyword at the end of the function signature.
• Do not modify any member variables of the class.
• Can be called on const objects.

Non-const Member Functions:

• Can modify member variables.
• Cannot be called on const objects.

Example:

class MyClass {
    int value;
public:
    int getValue() const { return value; } // Const member function
    void setValue(int v) { value = v; }    // Non-const member function
};

The explicit keyword is used to prevent the compiler from using constructors for implicit type conversions. It is applied to constructors that can be called with a single argument. This ensures that such constructors can only be used for direct initialization and not for implicit conversions.

class MyClass {
public:
    explicit MyClass(int x) {}
};

MyClass obj1 = 10; // Error: implicit conversion not allowed
MyClass obj2(10);  // Ok: direct initialization

Move semantics allow the resources of a temporary object to be moved to another object, rather than copied. This is particularly useful for optimizing the performance of code by eliminating unnecessary copies. The std::move function is used to indicate that an object’s resources can be moved.

class MyClass {
    std::string data;
public:
    MyClass(std::string d) : data(std::move(d)) {}
};

std::vector:

• Dynamic array that can grow and shrink in size.
• Size can be modified during runtime.
• Provides various member functions for manipulation (e.g., push_back , pop_back ).

std::array:

• Fixed-size array that cannot change size once initialized.
• Size is known at compile-time.
• Provides a safer alternative to C-style arrays with bounds checking.

Example:

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

The Rule of Three states that if a class defines one (or more) of the following, it should probably explicitly define all three:

• Destructor
• Copy Constructor
• Copy Assignment Operator

This is because these functions are often closely related, and failing to properly define one might lead to resource management issues.

class MyClass {
    int* data;
public:
    MyClass() : data(new int[10]) {}
    ~MyClass() { delete[] data; }
    MyClass(const MyClass& other) {
        data = new int[10];
        std::copy(other.data, other.data + 10, data);
    }
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete[] data;
            data = new int[10];
            std::copy(other.data, other.data + 10, data);
        }
        return *this;
    }
};

Smart pointers are objects that manage the lifetime of dynamically allocated objects. They are used to ensure that resources are properly released when they are no longer needed, preventing memory leaks and dangling pointers. C++ provides several types of smart pointers:

• std::unique_ptr : Manages a unique resource, ensuring that there is only one owner.
• std::shared_ptr : Manages a resource with shared ownership, using reference counting.
• std::weak_ptr : A weak reference to a std::shared_ptr that does not affect the reference count.

Example of std::unique_ptr :

std::unique_ptr ptr = std::make_unique(10);

struct:

• By default, all members are public.
• Typically used for passive objects that carry data (POD - Plain Old Data).

class:

• By default, all members are private.
• Typically used for active objects that combine data and methods.

Both struct and class can have member functions, constructors, destructors, and can participate in inheritance.

Example:

struct MyStruct {
    int data;
    void func() {}
};

class MyClass {
private:
    int data;
public:
    void func() {}
};

An inline function is a function where the compiler attempts to expand the function's body at each call site, instead of performing a regular function call. This can improve performance by eliminating the overhead of a function call, especially for small functions. However, it can increase the binary size.

Syntax:

inline void func() {
    // Function body
}

Usage:

• For small, frequently called functions.
• To reduce function call overhead.

A lambda function is an anonymous function defined within a scope and can capture variables from its enclosing scope. It is used for short, inline functions that are not reusable elsewhere.

Syntax:

[ capture list ] ( parameters ) -> return type {
    // Function body
}

Example:

auto add = [](int a, int b) -> int {
    return a + b;
};
std::cout << add(2, 3); // Outputs: 5

The mutable keyword is used to allow a member of an object to be modified even if the object is declared as const . This is useful for members that are conceptually not part of the object's logical state but need to be modified, such as caching mechanisms.

class MyClass {
    mutable int cache;
public:
    int getCache() const {
        cache++; // Allowed because cache is mutable
        return cache;
    }
};

Namespaces are used to organize code into logical groups and to prevent name collisions in larger projects. They allow for the same names to be used in different contexts without conflict.

Example:

namespace MyNamespace {
    void func() {
        std::cout << "Inside MyNamespace" << std::endl;
    }
}

int main() {
    MyNamespace::func();
    return 0;
}