C++ Interview Questions - May Edition

16. What is the difference between arrays and pointers?

Definition and Essence: An array is a collection of elements of the same type, stored contiguously in memory; a pointer is a variable that stores the address of another variable.
Memory Allocation: The memory allocation for an array is determined at compile time, with a fixed size; a pointer can point to different memory addresses at runtime, and its size is typically 4 bytes (32-bit system) or 8 bytes (64-bit system).
Access Method: An array accesses elements via an index, such as arr[i]; a pointer must use the dereference operator * to access the object it points to, such as *ptr.
Operations: Arrays can perform index operations and pointer arithmetic (e.g., arr + 1); pointers can perform arithmetic operations (e.g., ptr + 1) and relational operations (e.g., ptr1 < ptr2).
Lifecycle: The lifecycle of an array depends on its definition location; local arrays are destroyed at the end of the function, while global arrays are destroyed at the end of the program; the lifecycle of a pointer depends on its definition location and memory allocation method, with dynamically allocated memory needing to be manually released.

17. Discuss the differences between `strcpy`, `sprintf`, and `memcpy`.

Functionality:

strcpy: Used to copy a string that ends with '\0'.
sprintf: Used to format a string, converting various types of data into a string according to a specified format.
memcpy: Used to copy a block of memory of any type, without regard to the contents of the memory block.

Parameters:

strcpy:char* strcpy(char* dest, const char* src);
sprintf:int sprintf(char* str, const char* format,...);
memcpy:void* memcpy(void* dest, const void* src, size_t n);

Safety:

strcpy: Does not check the size of the destination buffer, which may lead to buffer overflow.
sprintf: May encounter format errors or buffer overflow when formatting strings.
memcpy: Requires manual specification of the number of bytes to copy; otherwise, it may lead to out-of-bounds memory access.

18. How are smart pointers implemented? How to use `weak_ptr`? How to convert `weak_ptr` to `shared_ptr`? How to solve the circular reference problem with smart pointers? Is `shared_ptr` thread-safe?

Implementation Principles of Smart Pointers:

std::unique_ptr: Implements exclusive ownership, meaning only one std::unique_ptr can point to a given object at any time. When this pointer is destroyed or reset, it automatically releases the managed object.

#include<memory>
std::unique_ptr<int> ptr = std::make_unique<int>(10);

std::shared_ptr: Implements shared ownership, allowing multiple std::shared_ptr to point to the same object. Through a reference counting mechanism, when the reference count reaches 0, the managed object is automatically released.#include<memory>std::shared_ptr<int> ptr1 = std::make_shared<int>(20);std::shared_ptr<int> ptr2 = ptr1;std::weak_ptr: A weak reference that does not affect the reference count of the object, primarily used to solve the circular reference problem of std::shared_ptr.#include<memory>std::shared_ptr<int> ptr = std::make_shared<int>(30);std::weak_ptr<int> weakPtr = ptr;

weak_ptr Usage: Typically used in conjunction with shared_ptr, it can be constructed from a shared_ptr or another weak_ptr, and attempts to obtain the pointed-to object’s shared_ptr using the lock method. If the object has been released, lock returns a null shared_ptr. For example:

std::shared_ptr<int> sp = std::make_shared<int>(42);
std::weak_ptr<int> wp(sp);
std::shared_ptr<int> sp2 = wp.lock(); // If the object exists, sp2 points to it; otherwise, it is null.

weak_ptr Conversion to shared_ptr: Call the lock method of weak_ptr; if the object exists, it returns a valid shared_ptr; if the object has been released, it returns a null shared_ptr.
Solving Circular Reference Problems: In classes with circular references, define one of the class’s pointer members as weak_ptr to break the circular reference, allowing the object reference count to correctly decrement to 0 and enabling normal object release. For example:

class B;
class A {
public:
    std::weak_ptr<B> ptrB;
};
class B {
public:
    std::shared_ptr<A> ptrA;
};

shared_ptr Thread Safety: The reference count update operation of shared_ptr is atomic, making it safe for multiple threads to access and modify the reference count of the same shared_ptr. However, simultaneous access and modification of the object pointed to by shared_ptr by multiple threads may lead to data races and undefined behavior, requiring additional synchronization mechanisms (such as mutexes) to ensure thread safety of object access.

19. What are the differences between `new` and `make_shared`?

Memory Allocation Mechanism:

new: Involves two steps, first allocating raw uninitialized memory using operator new, then calling the object’s constructor to initialize it. For example, int* p = new int(10);, first allocates memory for an int, then writes the value 10; when allocating an array, additional handling for element construction and destruction is required.
make_shared: Allocates memory in one step, simultaneously allocating memory for the object and the control block that stores reference counting and management information. It allocates a sufficiently large block of memory on the heap, part for the object and part for the control block data, reducing the number of memory allocations and overhead, such as std::shared_ptr<int> sp = std::make_shared<int>(10);.

Exception Handling:

new: When allocating memory and constructing an object, if the constructor throws an exception, the allocated object memory is automatically released (the compiler ensures that the destructor is called in case of construction failure to avoid memory leaks); if an exception occurs after memory allocation in operator new and before the constructor is called, there is no object created, so no destructor needs to be called.
make_shared: If an exception is thrown during the object construction process after memory allocation, since the memory is allocated in one go (both object memory and control block memory together), memory release is more complex, posing a risk of memory leaks, although modern standard libraries usually handle this properly.

Performance:

new: Two memory allocation operations incur additional overhead, including function call overhead and potential memory fragmentation issues, which can significantly impact performance when used frequently.
make_shared: One memory allocation reduces overhead and time, with the object and control block in the same memory area, improving cache hit rates, enhancing performance, and reducing memory allocation frequency helps to lower memory fragmentation and improve memory usage efficiency.

Applicable Scenarios:

new: Suitable for scenarios requiring precise control over memory allocation and release processes, such as custom memory management classes, or when there are special requirements for memory layout; when additional initialization operations that are not suitable for the constructor are needed after memory allocation, new is also a good choice.
make_shared: Preferably used when creating objects managed by std::shared_ptr, especially in scenarios where dynamic objects are frequently created and destroyed (such as containers storing dynamically allocated objects), simplifying code, improving performance, and reducing memory management complexity.

20. What is the difference between `const` and `constexpr`?

Constant Determination Time:const constants have their values determined at compile or runtime, initialized before use; constexpr constants must have their values determined at compile time, used to define compile-time constants.
Scope of Use:const can modify variables, function parameters, function return values, class member variables, etc.; constexpr can modify not only variables but also functions (constexpr functions), requiring the function to return a constant value at compile time. For example:

const int a = 10; // Runtime constant
constexpr int b = 20; // Compile-time constant
constexpr int add(int x, int y) {
    return x + y;
}

Compiler Optimization:constexpr constants and functions can be optimized more by the compiler (e.g., replaced with specific values, reducing runtime computation overhead); const constants may have limited optimization in certain cases.

21. When is the copy constructor called?

Object Initialization: Called when initializing a new object of the same type using an existing object, such as MyClass obj1; MyClass obj2(obj1); or MyClass obj2 = obj1; (where = is copy initialization).
Function Parameters: Called when passing parameters by value, creating a copy of the actual parameter to pass to the function. For example, void func(MyClass obj);, calling func(obj1); calls the copy constructor of MyClass.
Function Return Objects: Called when returning an object by value from a function, copying the internal object to the function call site. For example, MyClass func() { MyClass obj; return obj; }, calling func() returns an object, invoking the copy constructor.
Container Initialization or Inserting Elements: May call the copy constructor when using an existing object to initialize container elements or inserting objects into a container. For example, std::vector<MyClass> vec; vec.push_back(obj1); (if MyClass does not have a move constructor, or the compiler does not support move semantics optimization, the copy constructor will be called).

22. If there is an empty class, what functions will be added by default?

If a class is empty, the compiler will automatically add the following functions:

Default Constructor: Used to create objects of the class; when no constructors are provided, the compiler generates a default constructor automatically.

class EmptyClass {
public:
    // Default constructor
    EmptyClass() {}
};

Copy Constructor: Used to create a new object that is a copy of another object of the same type.

class EmptyClass {
public:
    // Copy constructor
    EmptyClass(const EmptyClass&amp; other) {}
};

Destructor: Called when an object is destroyed, used to release resources occupied by the object.

class EmptyClass {
public:
    // Destructor
    ~EmptyClass() {}
};

Assignment Operator Overload Function: Used to assign the value of one object to another object of the same type.

class EmptyClass {
public:
    // Assignment operator overload function
    EmptyClass&amp; operator=(const EmptyClass&amp; other) {
        return *this;
    }
};

23. Where is the virtual function table of the base class stored in memory, and when is the virtual table pointer `vptr` initialized?

Storage Location of the Virtual Function Table: The virtual function table of the base class is stored in the read-only data segment (.rodata), as the contents of the virtual function table remain fixed during program execution and belong to constant data.
Initialization Time of the Virtual Table Pointer: The vptr is initialized during the execution of the object’s constructor, before entering the constructor body, making it point to the virtual function table of the class to which the object belongs, ensuring that after the object is constructed, virtual functions can be correctly called.

24. How are `new` and `delete` implemented?

new Implementation: Divided into two steps, first calling the operator new function to allocate memory (operator new typically calls malloc to actually allocate memory), then calling the object’s constructor to initialize the object. Example code is as follows:

void* operator new(size_t size) {
    void* p = malloc(size);    if (!p) {        throw std::bad_alloc();    }    return p;
}
class Example {
public:
    Example() {        std::cout &lt;&lt; "Constructor called." &lt;&lt; std::endl;    }
};
int main() {
    Example* e = new Example();
    delete e;
    return 0;
}

delete Implementation: Also divided into two steps, first calling the object’s destructor to clean up the object’s resources, then calling the operator delete function to release memory (operator delete typically calls free to actually release memory).

25. In which situations must the member initializer list be used?

Constant Member Variables: Constant member variables cannot be modified after initialization and must be initialized in the member initializer list. For example:

class Example {
public:
    const int value;
    Example(int v) : value(v) {}
};

Reference Member Variables: Reference member variables must be initialized at the time of definition and cannot refer to other objects afterward, requiring initialization in the member initializer list. For example:

class Example {
public:
    int&amp; ref;
    Example(int&amp; r) : ref(r) {}
};

Class Members Without Default Constructors: If a class member is an object of a class that does not have a default constructor, it must be initialized in the member initializer list by calling that class’s constructor. For example:

class AnotherClass {
public:
    AnotherClass(int v) {}
};
class Example {
public:
    AnotherClass obj;
    Example(int v) : obj(v) {}
};

26. How is polymorphism implemented in C++?

Static Polymorphism (Compile-time Polymorphism):

Function Overloading: In the same class, functions with the same name but different parameter lists are selected by the compiler based on the types and number of actual parameters at the time of the call.
Templates: Achieve generic algorithms and data structures through template programming, with the compiler generating corresponding code based on template parameter types at compile time.

Dynamic Polymorphism (Runtime Polymorphism): Declaring virtual functions in the base class and overriding them in derived classes. When calling virtual functions through base class pointers or references, the actual type of the object determines which function is called, implemented at runtime through the virtual table.

27. What are the functions of the `final` and `override` keywords?

final: When modifying a class, it indicates that the class cannot be inherited, such as class FinalClass final {};; when modifying a virtual function, it indicates that the virtual function cannot be overridden in derived classes, such as virtual void func() final;.
override: Used in derived class virtual function declarations to explicitly indicate that the function overrides a base class virtual function. If the base class does not have a corresponding virtual function, the compiler will report an error, preventing failure to override due to spelling mistakes. For example:

class Base {
public:
    virtual void func() {}
};
class Derived : public Base {
public:
    void func() override {}
};

28. What are the uses of `auto`, `decltype`, and `decltype(auto)`?

auto: Used to automatically deduce variable types, with the compiler determining the variable type based on the initialization expression. For example:auto num = 10;, automatically deducing num as type int.
decltype: Obtains the type of an expression without evaluating the expression’s value. For example:int x = 5; decltype(x) y;, where y is of type int.
decltype(auto): Combines the features of decltype and auto, automatically deducing the type based on the initialization expression, with deduction rules similar to decltype. For example:

int&amp; func() {
    static int num = 10;
    return num;
}
decay_t<decltype(auto) <="" code="" int&amp;.="" is="" of="" ref="" type=""></decltype(auto)>

29. What is the difference between shallow copy and deep copy?

Shallow Copy: Simply copies the values of the object’s member variables; if the object contains pointer members, only the pointer values are copied, not the objects pointed to, leading to multiple objects sharing the same memory. When one of the objects releases memory, the other object’s pointer becomes a dangling pointer. For example:

class MyClass {
public:
    int* data;
    MyClass(int value) {
        data = new int(value);
    }
    // Shallow copy constructor
    MyClass(const MyClass&amp; other) : data(other.data) {}
    ~MyClass() {
        delete data;
    }
};

Deep Copy: Not only copies the values of the object’s member variables but also allocates new memory for pointer members and copies the objects pointed to into the new memory, ensuring each object has independent memory and does not affect each other. For example:

class MyClass {
public:
    int* data;
    MyClass(int value) {
        data = new int(value);
    }
    // Deep copy constructor
    MyClass(const MyClass&amp; other) {
        data = new int(*other.data);
    }
    ~MyClass() {
        delete data;
    }
};

30. What is the difference between dynamic compilation and static compilation?

Static Compilation: The compiler integrates the code of the library files that the program depends on into the executable file, generating an executable file that can run independently without external library files. However, the file size is larger, and when the library files are updated, the entire program must be recompiled.
Dynamic Compilation: The generated executable file loads the required library files at runtime, resulting in a smaller file size. When library files are updated and the interface remains unchanged, the executable file does not need to be recompiled, but it must ensure that the system has the corresponding library files at runtime; otherwise, the program cannot run.

31. Can template functions be virtual functions?

Template functions cannot be directly declared as virtual functions. Template functions are instantiated into specific functions at compile time, while virtual functions implement runtime polymorphism, relying on the virtual function table and dynamic binding mechanism of the object. Template functions determine specific function instances at compile time, which is incompatible with the runtime characteristics of virtual functions. However, virtual member functions can be defined in class templates, and these virtual member functions can achieve polymorphic behavior after instantiation. For example:

template <typename T>
class MyClass {
public:
    virtual void func() {
        // Virtual member function
    }
};
template class MyClass<int>;
template class MyClass<double>;

C++ Interview Questions – May Edition

16. What is the difference between arrays and pointers?

17. Discuss the differences between `<span>strcpy</span>`, `<span>sprintf</span>`, and `<span>memcpy</span>`.

18. How are smart pointers implemented? How to use `<span>weak_ptr</span>`? How to convert `<span>weak_ptr</span>` to `<span>shared_ptr</span>`? How to solve the circular reference problem with smart pointers? Is `<span>shared_ptr</span>` thread-safe?

19. What are the differences between `<span>new</span>` and `<span>make_shared</span>`?

20. What is the difference between `<span>const</span>` and `<span>constexpr</span>`?

21. When is the copy constructor called?

22. If there is an empty class, what functions will be added by default?

23. Where is the virtual function table of the base class stored in memory, and when is the virtual table pointer `<span>vptr</span>` initialized?

24. How are `<span>new</span>` and `<span>delete</span>` implemented?

25. In which situations must the member initializer list be used?

26. How is polymorphism implemented in C++?

27. What are the functions of the `<span>final</span>` and `<span>override</span>` keywords?

28. What are the uses of `<span>auto</span>`, `<span>decltype</span>`, and `<span>decltype(auto)</span>`?

29. What is the difference between shallow copy and deep copy?

30. What is the difference between dynamic compilation and static compilation?

31. Can template functions be virtual functions?

Leave a Comment Cancel reply

16. What is the difference between arrays and pointers?

17. Discuss the differences between <span>strcpy</span>, <span>sprintf</span>, and <span>memcpy</span>.

18. How are smart pointers implemented? How to use <span>weak_ptr</span>? How to convert <span>weak_ptr</span> to <span>shared_ptr</span>? How to solve the circular reference problem with smart pointers? Is <span>shared_ptr</span> thread-safe?

19. What are the differences between <span>new</span> and <span>make_shared</span>?

20. What is the difference between <span>const</span> and <span>constexpr</span>?

21. When is the copy constructor called?

22. If there is an empty class, what functions will be added by default?

23. Where is the virtual function table of the base class stored in memory, and when is the virtual table pointer <span>vptr</span> initialized?

24. How are <span>new</span> and <span>delete</span> implemented?

25. In which situations must the member initializer list be used?

26. How is polymorphism implemented in C++?

27. What are the functions of the <span>final</span> and <span>override</span> keywords?

28. What are the uses of <span>auto</span>, <span>decltype</span>, and <span>decltype(auto)</span>?

29. What is the difference between shallow copy and deep copy?

30. What is the difference between dynamic compilation and static compilation?

31. Can template functions be virtual functions?

Related posts

Leave a Comment Cancel reply

17. Discuss the differences between `<span>strcpy</span>`, `<span>sprintf</span>`, and `<span>memcpy</span>`.

18. How are smart pointers implemented? How to use `<span>weak_ptr</span>`? How to convert `<span>weak_ptr</span>` to `<span>shared_ptr</span>`? How to solve the circular reference problem with smart pointers? Is `<span>shared_ptr</span>` thread-safe?

19. What are the differences between `<span>new</span>` and `<span>make_shared</span>`?

20. What is the difference between `<span>const</span>` and `<span>constexpr</span>`?

23. Where is the virtual function table of the base class stored in memory, and when is the virtual table pointer `<span>vptr</span>` initialized?

24. How are `<span>new</span>` and `<span>delete</span>` implemented?

27. What are the functions of the `<span>final</span>` and `<span>override</span>` keywords?

28. What are the uses of `<span>auto</span>`, `<span>decltype</span>`, and `<span>decltype(auto)</span>`?