Write a program in c to implement a class to represent complex members . Include member function add and multiply two complex no .Overloaded assignment operator=

9. Compare compile time polymorphism and Runtime polymorphism

The main difference between compile-time and runtime polymorphism is provided below:

Example -

int add(int a, int b){
      return a+b;
}
int add(int a, int b, int c){
      return a+b+c;
}

int main(){
    Cout<<add(2,3)<<endl;
    Cout<<add(2,3,4)<<endl;


     return 0;
}

Example -

class A{
     public:
          virtual void fun(){
               Cout<<"base ";
          }
};
class B: public A{
     public:
          void fun(){
               Cout<<"derived ";
          }
};
int main(){
     A *a=new B;
     A->fun();

     return 0;
}

10. What do you know about friend class and friend function?

A friend class can access private, protected, and public members of other classes in which it is declared as friends.

Like friend class, friend function can also access private, protected, and public members. But, Friend functions are not member functions.

For example -

class A{
 private:
  int data_a;
 public:
  A(int x){
   Data_a=x;
  }
  friend int fun(A, B);
}
class B{
 private:
  int data_b;
 public:
  A(int x){
   Data_b=x;
  }
  friend int fun(A, B);
}
int fun(A a, B b){
 return a.Data_a+b.Data_b;
}
int main(){
 A a(10);
 B b(20);
 cout<<fun(a,b)<<endl;
 return 0;
}

Here we can access the private data of class A and class B.

11. What are the C++ access specifiers?

In C++ there are the following access specifiers:

Public: All data members and member functions are accessible outside the class.

Protected: All data members and member functions are accessible inside the class and to the derived class.

Private: All data members and member functions are not accessible outside the class.

12. Define inline function

If a function is inline, the compiler places a copy of the code of that function at each point where the function is called at compile time. One of the important advantages of using an inline function is that it eliminates the function calling overhead of a traditional function.

13. What is a reference in C++?

A reference is like a pointer. It is another name of an already existing variable. Once a reference name is initialized with a variable, that variable can be accessed by the variable name or reference name both.

For example-

int x=10;
int &ref=x;           //reference variable

If we change the value of ref it will be reflected in x. Once a reference variable is initialized it cannot refer to any other variable. We can declare an array of pointers but an array of references is not possible.

14. What do you mean by abstraction in C++?

Abstraction is the process of showing the essential details to the user and hiding the details which we don’t want to show to the user or hiding the details which are irrelevant to a particular user.

15. Is deconstructor overloading possible? If yes then explain and if no then why?

No destructor overloading is not possible. Destructors take no arguments, so there’s only one way to destroy an object. That’s the reason destructor overloading is not possible.

16. What do you mean by call by value and call by reference?

In call by value method, we pass a copy of the parameter is passed to the functions. For these copied values a new memory is assigned and changes made to these values do not reflect the variable in the main function.

In call by reference method, we pass the address of the variable and the address is used to access the actual argument used in the function call. So changes made in the parameter alter the passing argument.

17. What is an abstract class and when do you use it?

A class is called an abstract class whose objects can never be created. Such a class exists as a parent for the derived classes. We can make a class abstract by placing a pure virtual function in the class.

18. What are destructors in C++?

A constructor is automatically called when an object is first created. Similarly when an object is destroyed a function called destructor automatically gets called. A destructor has the same name as the constructor (which is the same as the class name) but is preceded by a tilde.

Example:

class A{
 private:
  int val;
 public:
  A(int x){           
   Val=x;
  }
  A(){                
  }
  ~A(){                  //destructor
  }
}
int main(){
 A a(3);     
 return 0;
}

19. What are the static members and static member functions?

When a variable in a class is declared static, space for it is allocated for the lifetime of the program. No matter how many objects of that class have been created, there is only one copy of the static member. So same static member can be accessed by all the objects of that class.

A static member function can be called even if no objects of the class exist and the static function are accessed using only the class name and the scope resolution operator ::

20. Explain inheritance

Inheritance is the process of creating new classes, called derived classes, from existing classes. These existing classes are called base classes. The derived classes inherit all the capabilities of the base class but can add new features and refinements of their own.

Example-

Inheritance in C++

Class Bus, Class Car, and Class Truck inherit the properties of Class Vehicle.

The most important thing about inheritance is that it permits code reusability.

C++ Interview Questions For Experienced

21. What is a copy constructor?

A copy constructor is a member function that initializes an object using another object of the same class.

Example-

class A{
int x,y;
A(int x, int y){
 this->x=x;
 this->y=y;
}

};
int main(){
A a1(2,3);
A a2=a1;     //default copy constructor is called
return 0;
}

We can define our copy constructor. If we don’t define a copy constructor then the default copy constructor is called.

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

The difference between shallow copy and a deep copy is given below:

23. What is the difference between virtual functions and pure virtual functions?

A virtual function is a member function in the base class that you redefine in a derived class. It is declared using the virtual keyword.

Example-

class base{
public:
 virtual void fun(){

 }
};

A pure virtual function is a function that has no implementation and is declared by assigning 0. It has no body.

Example-

class base{
public:
 virtual void fun()=0;
};

Here, = sign has got nothing to do with the assignment, and value 0 is not assigned to anything. It is used to simply tell the compiler that a function will be pure and it will not have anybody.

24. If class D is derived from a base class B. When creating an object of type D in what order would the constructors of these classes get called?

The derived class has two parts, a base part, and a derived part.  When C++ constructs derived objects, it does so in phases. First, the most-base class(at the top of the inheritance tree) is constructed. Then each child class is constructed in order until the most-child class is constructed last. 
So the first Constructor of class B will be called and then the constructor of class D will be called.

During the destruction exactly reverse order is followed. That is destructor starts at the most-derived class and works its way down to base class.
So the first destructor of class D will be called and then the destructor of class B will be called.

25. Can we call a virtual function from a constructor?

Yes, we can call a virtual function from a constructor. But the behavior is a little different in this case. When a virtual function is called, the virtual call is resolved at runtime. It is always the member function of the current class that gets called. That is the virtual machine doesn’t work within the constructor.

For example-

class base{
 private:
  int value;
 public:
  Base(int x){
   Value=x;
  }
  virtual void fun(){
   
  }
}

class derived{
 private:
  int a;
 public:
  Derived(int x, int y):base(x){
   Base *b;
   B=this;
   B->fun();      //calls derived::fun()
  }
  void fun(){
   cout<<”fun inside derived class”<<endl;
  }
}

26. What are void pointers?

A void pointer is a pointer which is having no datatype associated with it. It can hold addresses of any type.

For example-

void *ptr; 
char *str;
P=str;                // no error 
Str=p;                // error because of type mismatch

We can assign a pointer of any type to a void pointer but the reverse is not true unless you typecast it as

str=(char*) ptr;

27. What is this pointer in C++?

The member functions of every object have a pointer named this, which points to the object itself. The value of this is set to the address of the object for which it is called. It can be used to access the data in the object it points to.

Example

class A{
 private:
  int value;
 public:
  void setvalue(int x){
   this->value=x; 
  }
};

int main(){
 A a;
 A.Setvalue(5);
 return 0;
}

28. How do you allocate and deallocate memory in C++?

The new operator is used for memory allocation and deletes operator is used for memory deallocation in C++.

For example-

int value=new int;  		//allocates memory for storing 1 integer
delete value;          		// deallocates memory taken by value

int *arr=new int[10];    	//allocates memory for storing 10 int
delete []arr;              	// deallocates memory occupied by arr

std::vector<int> v;

//---------------------------------
// General Operations
//---------------------------------

// Size
Unsigned int size = v.Size();

// Insert head, index, tail
V.Insert(v.Begin(), value);             // head
V.Insert(v.Begin() + index, value);     // index
V.Push_back(value);                     // tail

// Access head, index, tail
Int head = v.Front();       // head
Head = v[0];                // or using array style indexing

Int value = v.At(index);    // index
Value = v[index];           // or using array style indexing

Int tail = v.Back();        // tail
Tail = v[v.Size() - 1];     // or using array style indexing

// Iterate
For(std::vector<int>::iterator it = v.Begin(); it != v.End(); it++) {
    Std::cout << *it << std::endl;
}

// Remove head, index, tail
V.Erase(v.Begin());             // head
V.Erase(v.Begin() + index);     // index
V.Pop_back();                   // tail

// Clear
V.Clear();

std::deque<int> d;

//---------------------------------
// General Operations
//---------------------------------

// Insert head, index, tail
D.Push_front(value);                    // head
D.Insert(d.Begin() + index, value);     // index
D.Push_back(value);                     // tail

// Access head, index, tail
Int head = d.Front();       // head
Int value = d.At(index);    // index
Int tail = d.Back();        // tail

// Size
Unsigned int size = d.Size();

// Iterate
For(std::deque<int>::iterator it = d.Begin(); it != d.End(); it++) {
    Std::cout << *it << std::endl;
}

// Remove head, index, tail
D.Pop_front();                  // head
D.Erase(d.Begin() + index);     // index
D.Pop_back();                   // tail

// Clear
D.Clear();

std::list<int> l;

//---------------------------------
// General Operations
//---------------------------------

// Insert head, index, tail
L.Push_front(value);                    // head
L.Insert(l.Begin() + index, value);     // index
L.Push_back(value);                     // tail

// Access head, index, tail
Int head = l.Front();                                           // head
Int value = std::next(l.Begin(), index);		        // index
Int tail = l.Back();                                            // tail

// Size
Unsigned int size = l.Size();

// Iterate
For(std::list<int>::iterator it = l.Begin(); it != l.End(); it++) {
    Std::cout << *it << std::endl;
}

// Remove head, index, tail
L.Pop_front();                  // head
L.Erase(l.Begin() + index);     // index
L.Pop_back();                   // tail

// Clear
L.Clear();

//---------------------------------
// Container-Specific Operations
//---------------------------------

// Splice: Transfer elements from list to list
//	splice(iterator pos, list &x)
//  	splice(iterator pos, list &x, iterator i)
//  	splice(iterator pos, list &x, iterator first, iterator last)
L.Splice(l.Begin() + index, list2);

// Remove: Remove an element by value
L.Remove(value);

// Unique: Remove duplicates
L.Unique();

// Merge: Merge two sorted lists
L.Merge(list2);

// Sort: Sort the list
L.Sort();

// Reverse: Reverse the list order
L.Reverse();

std::map<std::string, std::string> m;

//---------------------------------
// General Operations
//---------------------------------

// Insert
M.Insert(std::pair<std::string, std::string>("key", "value"));

// Access by key
Std::string value = m.At("key");

// Size
Unsigned int size = m.Size();

// Iterate
For(std::map<std::string, std::string>::iterator it = m.Begin(); it != m.End(); it++) {
    Std::cout << (*it).First << " " << (*it).Second << std::endl;
}

// Remove by key
M.Erase("key");

// Clear
M.Clear();

//---------------------------------
// Container-Specific Operations
//---------------------------------

// Find if an element exists by key
Bool exists = (m.Find("key") != m.End());

// Count the number of elements with a certain key
Unsigned int count = m.Count("key");

std::set<int> s;

//---------------------------------
// General Operations
//---------------------------------

// Insert
S.Insert(20);

// Size
Unsigned int size = s.Size();

// Iterate
For(std::set<int>::iterator it = s.Begin(); it != s.End(); it++) {
    Std::cout << *it << std::endl;
}

// Remove
S.Erase(20);

// Clear
S.Clear();

//---------------------------------
// Container-Specific Operations
//---------------------------------

// Find if an element exists
Bool exists = (s.Find(20) != s.End());

// Count the number of elements with a certain value
Unsigned int count = s.Count(20);

std::stack<int> s;

//---------------------------------
// Container-Specific Operations
//---------------------------------

// Push
S.Push(20);

// Size
Unsigned int size = s.Size();

// Pop
S.Pop();

// Top
Int top = s.Top();

std::queue<int> q;

//---------------------------------
// General Operations
//---------------------------------

// Insert
Q.Push(value);

// Access head, tail
Int head = q.Front();       // head
Int tail = q.Back();        // tail

// Size
Unsigned int size = q.Size();

// Remove
Q.Pop();

std::priority_queue<int> p;

//---------------------------------
// General Operations
//---------------------------------

// Insert
P.Push(value);

// Access
Int top = p.Top();  // 'Top' element

// Size
Unsigned int size = p.Size();

// Remove
P.Pop();