Conteúdo do Curso

C++ OOP

1. Fundamentals of OOP in C++

Introduction to Object-Oriented Programming in C++Why use Object-Oriented Programming?Class Creation Syntax Attributes of the Class Methods of the Class Static Members of The Class The This Keyword Classes and Objects Overview

2. Constructors and Destructors

What is a Constructor of the Class Constructor and Attributes Constructor Initialization List Initialization List Practice Constructor Delegation Constructor Delegation Practice What is a Destructor of the Class Constructors and Destructors Practice

3. Encapsulation Overview

Introduction to Encapsulation Access Modifiers Keywords Access Modifiers Practice Accessor and Mutator Methods Segmentation and Aggregation The Friend Keyword

4. Inheritance Overview

Introduction to Inheritance Access Modifiers in Inheritance Mulptiple Inheritance Constructor and Destructor in Inheritance Diamond Inheritance The Final Keyword

5. Polymorphism Overview

Introduction to Polymorphism Virtual and Override Keywords Pure Virtual Method Operator Overloading

Diamond Inheritance

Multiple inheritance can lead to a situation known as the diamond problem or diamond inheritance, which is a significant challenge in object-oriented programming languages that support multiple inheritance.

This occurs when a subclass inherits from two or more classes, which themselves inherit from a common superclass. The term diamond is used because the inheritance scheme resembles the shape of a diamond.

main.cpp


              1234567
            
class Base {};

class Derived1 : public Base {};

class Derived2 : public Base {};

class Diamond : public Derived1, public Derived2 {};

The primary issue with diamond inheritance is the ambiguity it creates. Since Diamond inherits from both Derived1 and Derived2, which in turn inherit from Base, there are two copies of Base within an object of Diamond. This can lead to ambiguity.

main.cpp


              12345678910111213141516
            
#include <iostream>

class Base {
public:
    void display() { std::cout << "Base display()" << std::endl; }
};

class Derived1 : public Base { };
class Derived2 : public Base { };
class Diamond : public Derived1, public Derived2 { };

int main() 
{
    Diamond obj;
    obj.display(); // Ambiguity: Which display() method should be called?
}

Solution to the problem

The virtual keyword helps to avoid this problem. You can address this ambiguity through virtual inheritance by using the virtual keyword. When Diamond inherits virtually, C++ ensures that only one copy of the superclass is present, even if it is inherited multiple times through different paths.

main.cpp


              1234567
            
class Base {};

class Derived1 : virtual public Base {};

class Derived2 : virtual public Base {};

class Diamond : public Derived1, public Derived2 {};

Note

Try to resolve the ambiguity issue in the previous example by utilizing virtual inheritance.

Implementing Diamond Inheritance

To implement diamond inheritance effectively, use the virtual keyword in the superclass declaration within the intermediate classes. Ensure consistent use of virtual inheritance in all paths of the inheritance hierarchy, and be mindful of the constructor and destructor calls order.

Resolving Ambiguities

One of the challenges of multiple inheritance is also dealing with potential ambiguities when it comes to members with the same names.

main.cpp


              12345678910111213141516171819
            
#include <iostream>

class Base {};

class Derived1 : public Base {
public:
    void display() { std::cout << "Derived1 display()" << std::endl; }
};
class Derived2 : public Base {
public:
    void display() { std::cout << "Derived2 display()" << std::endl; }
};

class Diamond : public Derived1, public Derived2 { };

int main() {
    Diamond obj;
    obj.display(); // Ambiguity: Which display() method should be called?
}

If both superclasses have members with the same name, the subclass may not know which one to use. To resolve such ambiguities, you can use the scope resolution operator (::) to specify which base class's member you want to access. For example:

main.cpp


              1234567891011121314151617181920
            
#include <iostream>

class Base {};

class Derived1 : public Base {
public:
    void display() { std::cout << "Derived1 display()" << std::endl; }
};
class Derived2 : public Base {
public:
    void display() { std::cout << "Derived2 display()" << std::endl; }
};

class Diamond : public Derived1, public Derived2 { };

int main() {
    Diamond obj;
    obj.Derived1::display();
    obj.Derived2::display();
}

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 4. Capítulo 5

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Conteúdo do Curso

C++ OOP

1. Fundamentals of OOP in C++

2. Constructors and Destructors

3. Encapsulation Overview

Introduction to Encapsulation Access Modifiers Keywords Access Modifiers Practice Accessor and Mutator Methods Segmentation and Aggregation The Friend Keyword

4. Inheritance Overview

Introduction to Inheritance Access Modifiers in Inheritance Mulptiple Inheritance Constructor and Destructor in Inheritance Diamond Inheritance The Final Keyword

5. Polymorphism Overview

Introduction to Polymorphism Virtual and Override Keywords Pure Virtual Method Operator Overloading

Diamond Inheritance

main.cpp


              1234567
            
class Base {};

class Derived1 : public Base {};

class Derived2 : public Base {};

class Diamond : public Derived1, public Derived2 {};

main.cpp


              12345678910111213141516
            
#include <iostream>

class Base {
public:
    void display() { std::cout << "Base display()" << std::endl; }
};

class Derived1 : public Base { };
class Derived2 : public Base { };
class Diamond : public Derived1, public Derived2 { };

int main() 
{
    Diamond obj;
    obj.display(); // Ambiguity: Which display() method should be called?
}

Solution to the problem

main.cpp


              1234567
            
class Base {};

class Derived1 : virtual public Base {};

class Derived2 : virtual public Base {};

class Diamond : public Derived1, public Derived2 {};

Note

Try to resolve the ambiguity issue in the previous example by utilizing virtual inheritance.

Implementing Diamond Inheritance

Resolving Ambiguities

One of the challenges of multiple inheritance is also dealing with potential ambiguities when it comes to members with the same names.

main.cpp


              12345678910111213141516171819
            
#include <iostream>

class Base {};

class Derived1 : public Base {
public:
    void display() { std::cout << "Derived1 display()" << std::endl; }
};
class Derived2 : public Base {
public:
    void display() { std::cout << "Derived2 display()" << std::endl; }
};

class Diamond : public Derived1, public Derived2 { };

int main() {
    Diamond obj;
    obj.display(); // Ambiguity: Which display() method should be called?
}

main.cpp


              1234567891011121314151617181920
            
#include <iostream>

class Base {};

class Derived1 : public Base {
public:
    void display() { std::cout << "Derived1 display()" << std::endl; }
};
class Derived2 : public Base {
public:
    void display() { std::cout << "Derived2 display()" << std::endl; }
};

class Diamond : public Derived1, public Derived2 { };

int main() {
    Diamond obj;
    obj.Derived1::display();
    obj.Derived2::display();
}

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 4. Capítulo 5