How C++ manage its memory? Explain new & delete operators for variables, objects and arrays.

• C++ manages memory manually using new and delete operators. The new operator allocates memory on the heap for variables, objects, or arrays and returns a pointer to the allocated memory. The delete operator deallocates memory previously allocated by new.
  • Example for variables: int* p = new int; delete p;
  • Example for objects: MyClass* obj = new MyClass(); delete obj;
  • Example for arrays: int* arr = new int[10]; delete[] arr;

Is it possible to delete storage acquired by a local variable in static memory using delete keyword in C++?

• No, the delete keyword is used to deallocate memory that was dynamically allocated using new. Local variables in static memory are automatically managed and should not be manually deleted.

What is the use of destructors? Write a legal example of a destructor.

• Destructors are used to release resources and perform cleanup when an object is destroyed. They are automatically called when an object goes out of scope or is explicitly deleted.

  • Example:

    class MyClass {
    public:
        ~MyClass() {
            // Cleanup code
        }
    };
    
    

What are the OOP concepts present in C++/Java? Explain with one example each.

• Encapsulation: Bundling data and methods that operate on the data within a single unit.
  • Example: A class with private data members and public methods.
• Inheritance: Creating a new class from an existing class.
  • Example: class Dog : public Animal {};
• Polymorphism: Ability to present the same interface for different underlying forms.
  • Example: Function overloading or overriding.
• Abstraction: Hiding complex implementation details.
  • Example: Abstract classes or interfaces.

How to create an abstract class in C++? How to write a pure virtual function? Can we write a body of pure virtual function?

• An abstract class is created by declaring at least one pure virtual function. A pure virtual function is declared using = 0.

  • Example:

    class AbstractClass {
    public:
        virtual void pureVirtualFunction() = 0;
    };
    
    

• A pure virtual function can have a body, but it must be defined outside the class.

What is getter and setter? Why do we use that? Write down a small code example.

• Getters and setters are methods used to access and modify private data members of a class.

  • Example:

    class MyClass {
    private:
        int value;
    public:
        int getValue() { return value; }
        void setValue(int v) { value = v; }
    };
    
    

Create a spiral matrix.

• Here is a C++ implementation:

  vector<vector<int>> generateMatrix(int n) {
      vector<vector<int>> matrix(n, vector<int>(n));
      int num = 1;
      int left = 0, right = n - 1, top = 0, bottom = n - 1;
      while (left <= right && top <= bottom) {
          for (int i = left; i <= right; i++) matrix[top][i] = num++;
          top++;
          for (int i = top; i <= bottom; i++) matrix[i][right] = num++;
          right--;
          for (int i = right; i >= left; i--) matrix[bottom][i] = num++;
          bottom--;
          for (int i = bottom; i >= top; i--) matrix[i][left] = num++;
          left++;
      }
      return matrix;
  }
  
  

What is "this" pointer? Is it available for static, virtual, const and friend functions?

• The this pointer is a pointer to the current object instance. It is available for non-static member functions, including virtual and const functions, but not for static or friend functions.

What is the need to write a user defined destructor? When should it be declared as "virtual"?

• A user-defined destructor is needed when an object manages resources that need explicit release. It should be declared as virtual when the class is intended to be a base class in an inheritance hierarchy to ensure proper cleanup of derived class objects.

How does virtual function affect the size of an object? How are they executed at runtime?

• Virtual functions increase the size of an object by adding a virtual table pointer. They are executed at runtime through dynamic dispatch using the virtual table.

What is the diamond problem? How to solve it?

• The diamond problem occurs in multiple inheritance when a class inherits from two classes that both inherit from a common base class. It can be solved using virtual inheritance.

  • Example:

    class A {};
    class B : virtual public A {};
    class C : virtual public A {};
    class D : public B, public C {};
    
    

What is shallow copy and deep copy? How is it implemented in C++? Explain with examples.

• Shallow copy: Copies the memory address of the pointer, not the data it points to.
• Deep copy: Copies the data pointed to by the pointer.

  • Example:

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

What is a smart pointer? Which are smart pointers in C++?

• Smart pointers are objects that manage the lifetime of dynamically allocated memory. C++ provides std::unique_ptr, std::shared_ptr, and std::weak_ptr.

What is STL? Explain different components in STL with examples.

• STL (Standard Template Library) is a library in C++ that provides templates for common data structures and algorithms.
  • Containers: vector, list, map, etc.
  • Algorithms: sort, find, binary_search, etc.
  • Iterators: Used to traverse containers.
  • Functors: Function objects used in algorithms.