QNA | C++

The “diamond problem” is an ambiguity that can occur in languages that support multiple inheritance, such as C++. It’s called the “diamond problem” because of the shape of the class diagram, which resembles a diamond. It means that we cannot create hybrid inheritance using multiple and hierarchical inheritance.

For example:

class Base {
public:
    void foo();
};

class Derived1 : public Base {
    // ...
};

class Derived2 : public Base {
    // ...
};

class Diamond : public Derived1, public Derived2 {
    // ...
};

In this example, if foo() is called, on an object of type Diamond, it’s ambiguous whether it should call Derived1::foo() or Derived2::foo(), because both Derived1 and Derived2 are derived from Base and could have overridden foo().

To resolve this ambiguity, C++ provides the virtual keyword to specify that only one shared instance of the base class should be inherited:

class Base {
public:
    void foo();
};

class Derived1 : virtual public Base {
    // ...
};

class Derived2 : virtual public Base {
    // ...
};

class Diamond : public Derived1, public Derived2 {
    // ...
};

Now, Diamond will only have one Base, and calling foo() is unambiguous. This is known as “virtual inheritance”.

In C++11 and later, these concepts are further refined with the introduction of lvalue references and rvalue references, which are used to implement features like move semantics and perfect forwarding.

For example:

class MyClass {
public:
    mutable int counter;
    int value;

    void increment() const {
        counter++;  // This is allowed because counter is declared as mutable
        // value++; // This would be an error because value is not mutable
    }
};

In this example, increment() is a const member function, which means it’s not allowed to modify the object. However, because counter is declared as mutable, it can be modified inside increment().

Explain the different ways of type casting

Q) What is a friend class and when it is used?

A friend class is one that is allowed access to the private and protected members of any class that has declared it a friend. The property is not inherited (sub classes of friends do not become friends automatically), and not transitive (friends of friends are not friends).

Q) What are the advantages and disadvantages of using recursion? Where it is well suited?

Recursion is often slower compared to its iterative counterpart mainly because, a recursive function uses more memory. Each recursive function call reserves additional space on the stack, causing it to grow.
If the recursion is too “deep”,it can result in a “stack overflow” error.

Examples: Tree structures, such as a binary search tree,  when there is a variable number (or a very large number) of nested loops,  Sorting algorithms such as Merge sort, Quick sort, and Bubble sort are all easier to implement recursively

Q) Describe unique_ptr, shared_ptr, weak_ptr

Q) What are functors and their advantages?

Functor (also called function object) is a C++ class with operator() defined. This lets the user create objects that can used like a function. These are effectively used in C++ STLs.

Here is how functors are declared:

#include <algorithm>
#include <iostream>

using namespace std;

int add(int x)
{
   return (x + 1);
}

class functorAdd
{
private:
   int x;
public:
   functorAdd(int val) : x(val) {}
   int operator()(int y) const
   {
      return x + y;
   }
};
//------------------------------
int main()
{
   int intArray[] = { 1, 2, 3, 4, 5 };
   int n = sizeof(intArray) / sizeof(intArray[0]);

   transform(intArray, intArray + n, intArray, functorAdd(10));

   for (int i = 0; i < n; i++)
      cout << intArray[i] << " ";
   return 0;
}

In the above program, we are trying to add 10 to each item of array. The output of above program will be “11 12 13 14 15”.

Q) What is lambda and how do they compare with functors and functions?

A lambda is a syntactic shortcut for a functor, and can be used replace functors.

#include 
using namespace std;

int main()
{
  auto lf = []() { cout << "statement" << endl; };
  lf(); //invoke lambda
}

In the above example the lambda function can be written in the following ways that are equivalent

auto lambda = [] { cout << "statement" << endl; };
auto lambda = [](void) { cout << "statement" << endl; };
auto lambda = [](void) -> void { cout << "statement" << endl; };

Notes:

 Here is the example of function, functor and lambda doing the same thing:

#include <algorithm>
#include <iostream>

using namespace std;

int function(int param)
{
  return 10 * param;
}

class Functor
{
public:
	int operator()(int param)
	{
  return 10 * param;
	}
};

int main()
{
  auto lambda = [](int param)
  { return 10 * param; };

  Functor functor;

  int function_out = function(3);
  int functor_out = functor(3); 
  int lambda_out = lambda(3);
  cout << "function_out:" << function_out << endl;
  cout << "functor_out:" << functor_out << endl;
  cout << "lambda_out:" << lambda_out << endl;
  return 0;
}

The output of above program is:
function_out:30
functor_out:30
lambda_out:30

Q) Difference between auto_ptr and unique_ptr

Q) How can a C function be called in a C++ program?

Using an extern “C” declaration:

//C code
void func(int i){/* code */}
void print(int i){/* code */}

//C++ code
extern "C"{
void func(int i);
void print(int i);
}

void myfunc(int i)
{
func(i);
print(i);
}