Diamond Problem in C++

When employing numerous inheritances, a diamond problem can arise in computer languages, particularly in C++. When the code is exceedingly long, many inheritances in C++ are frequently utilized as a technique. So, in order to organize the program and the source code, we utilize classes. However, if they are not handled appropriately, multiple inheritances might be problematic. The DIAMOND issue is mostly present in these puzzles. The primary causes of the diamond problem, how it results from numerous inheritances, and all the remedies needed to overcome it are highlighted in this lesson.

System Requirement for the code

You need to have an Ubuntu system installed and running on the virtual machine in order to run the applications pertaining to "C++ diamond inheritance" under the Linux operating system. It takes two tools. One is any editing tool; therefore we'll utilize Linux's built-in "text editor" for this. Other favorite editing tools are available. The Ubuntu terminal is the second one which you will use to run the program and view the output. Since the "diamond problem" arises when inheritance is present in the source code, we will first talk about many inheritances in this article.

Multiple Inheritances

For instance, in a real-world scenario, if a mother and a father conceive a kid, the child will inherit everything from the parents. As a result, it is recognized that the mother and father of this kid are of a derived class. Returning to the various inheritances, let's go. "Constructors" will be used throughout the course of this conversation. When there are multiple inheritances, the constructors of an inherited class (child class) run in the order of the ancestors. For the destructors, however, the inheritance order is reversed. We will now use a straightforward example to illustrate how inheritance works in C++.

A class may inherit from multiple classes thanks to C++'s Multiple Inheritance feature. Inherited classes' constructors are called in the same order that they were inherited. For instance, in the program below, class second constructor is called before A.

A class can descend from many base classes.

Example:

The FATHER and MOTHER classes are the ancestors of the CHILD class.
The LIQUID and FUEL classes give rise to the PETROL class.

class A
{ 
// ,,,,,,,,,,,,,
};
class B
{
// ,,,,,,,,,,,,,,
};
class C: public A,public B
{
// ,,,,,,,,,,,,,
};

Let us look at an example to better understand the concept:

# include < iostream >
using namespace std ;
class one
{
public:
one ( ) { cout << " one's constructor is called here " << endl ; }
} ;
class two
{
public:
two ( ) { cout << "two's constructor is called here " << endl ; }
} ;
class three : public two , public one // Note the order
{
public:
three ( ) { cout << " C's constructor called " << endl ; }
} ;
int main()
{
	three th ;
	return 0 ; 
}

OUTPUT:

two's constructor is called here
one's constructor is called here
three's constructor is called here
?????????????????..
Process executed in 0.11 seconds
Press any key continue.

The destructors are called after the constructors, in reverse order.

The Diamond Problem: When two super classes of a class share a base class, the diamond issue arises. For instance, in the diagram below, the TA class receives two copies of every attribute from the Person class, which results in ambiguities. Think about the following program, for instance.

# include < iostream >
using namespace std ;
class Base {
// Data members of Base class
public :
	Base ( int a ) { cout < < " Base :: Base ( int ) called " < < endl ; }
} ;
class Derived : public Base {
// data members of Derived
public :
	Derived ( int a ) : Base ( a ) {
	cout < < " Derived :: Derived ( int ) called " < < endl ;
	}
} ;
class Derived_2 : public Base {
// data members of Derived_2
public :
	Derived_2 ( int a ) : Base ( a ) {
		cout < < " Derived_2 :: Derived_2 ( int ) called " < < endl ;
	}
} ;
class Result : public Derived , public Derived_2 {
public :
	Result ( int a ) : Derived_2 ( a ) , Derived ( a ) {
		cout < < " Result :: Result ( int ) called " < < endl ;
	}
} ;
int main ( ) {
	Result rs1 ( 30 ) ;
}

OUTPUT:

Base :: Base ( int ) called
Derived :: Derived ( int ) called
Base :: Base ( int ) called
Derived_2 :: Derived_2 ( int ) called
Result :: Result ( int ) called
?????????????????..
Process executed in 0.11 seconds
Press any key continue.

Explanation

The class "Base" is called twice in the code mentioned above. When object "rs1" is destroyed, the destructor of "Base" will likewise be invoked twice. Due to the fact that object "rs1" contains two of every "Base" element, confusion results. This issue may be solved by using the phrase "virtual." To prevent having two instances of "Base" in the "Result" class, we create the classes "Derived" and "Derived_2" as virtual base classes. Think about the following program, for instance.

# include < iostream >
using namespace std ;
class Base {
public :
	Base ( int x ) { cout < < " Base :: Base ( int ) is called " < < endl ; }
	Base ( ) { cout < < "Base :: Base ( ) is called " < < endl ; }
} ;
class Derived : virtual public Base {
public :
	Derived ( int a ) :: Base ( a ) {
	cout < < "Derived :: Derived ( int ) is called " < < endl ;
	}
} ;
class Derived_1 : virtual public Derived {
public :
	Derived_1 ( int a ) : Derived ( a ) {
		cout < < " Derived_1 :: Derived_1 ( int ) is called " < < endl ;
	}
} ;
class Result : public Derived_1 , public Derived {
public :
	Result ( int a ) : Derived_1 ( a ) , Derived ( a ) {
		cout < < " Result :: Result ( int ) is called " < < endl ;
	}
} ;
int main ( ) {
	Result rs1 ( 30 ) ;
}

OUTPUT:

Base :: Base ( ) is called
Derived :: Derived ( int ) is called
Derived_1 :: Derived_1 ( int ) is called
Result :: Result ( int ) is called	
?????????????????..
Process executed in 0.11 seconds
Press any key continue.

Explanation

A single call to the function Object() { [native code] } for "Person" is made in the program above. The fact that the default function Object() { [native code] } of "Person" is called in the output mentioned above is crucial to notice. Even if the parent classes explicitly call the parameterized function Object() { [native code] }, the default function Object() { [native code] } of the grandparent class is invoked by default when the "virtual" keyword is used. How can I use the 'Person' class's parameterized function Object() { [native code] }? In the "TA" class, the function Object() { [native code] } must be invoked. Take the following software as an illustration.

# include < iostream >
using namespace std ;
class Base {
public :
Base ( int a ) { cout < < " Base :: Base ( int ) is called " < < endl ; }
Base () { cout < < " Base :: Base ( ) is called " < < endl ; }
} ;
class Derived : virtual public Base {
public :
Derived ( int a ) : Person ( a ) {
cout < < " Derived :: Derived ( int ) is called " < < endl ;
}
} ;
Class Derived_1 : virtual public Derived {
public :
Derived_1 ( int a ) : Derived ( a ) {
cout < < " Derived_1 :: Derived_1 ( int ) is called " < < endl ;
}
} ;
class Result : public Derived_1 , public Derived {
public :
Result ( int a ) : Derived ( a ) , Derived ( a ) , Base ( a ) {
cout < < " Result :: Result ( int ) is called " < < endl ;
}
} ; 
int main ( ) {
Result rs1 ( 30 ) ;
}

OUTPUT:

Base :: Base ( int ) is called
Derived :: Derived ( int ) is called
Derived_1 :: Derived_1 ( int ) is called
Result :: Result ( int ) is called
?????????????????..
Process executed in 0.11 seconds
Press any key continue.

Explanation

The function Object() { [native code] } of a grandparent must typically be called through the parent class rather than directly. Only when the keyword "virtual" is used is it permitted.

Next TopicFunction Prototype in C++

← prev next →