Cursusinhoud

C++ OOP

1. Fundamenten van OOP in C++

Introductie tot Objectgeoriënteerd Programmeren in C++Waarom Objectgeoriënteerd Programmeren Gebruiken?Syntaxis voor het Aanmaken van een Klasse Attributen van de Klasse Methoden van de Klasse Statische Leden van de Klasse Het This-keyword Overzicht van Klassen en Objecten

2. Constructors en Destructors

Wat Is een Constructor van de Klasse Constructor en Attributen Constructor-Initialisatielijst Oefening met Initialisatielijst Constructor-Delegatie Oefening met Constructor-Delegatie Wat Is Een Destructor van de Klasse Oefening met Constructors en Destructors

3. Overzicht van Encapsulatie

Introductie tot Encapsulatie Sleutelwoorden voor Toegangsmodificatoren Oefening Met Toegangsmodificatoren Accessor- en Mutatormethoden Segmentatie en Aggregatie Het Friend-sleutelwoord

4. Overzicht van Overerving

Introductie tot Overerving Toegangsmodificatoren bij Overerving Meervoudige Overerving Constructor en Destructor in Overerving Diamant-erfenis Het Final-sleutelwoord

5. Overzicht van Polymorfisme

Introductie tot Polymorfisme Virtual- en Override-trefwoorden Pure Virtuele Methode Operatoroverbelasting

Diamant-erfenis

Meervoudige overerving kan leiden tot een situatie die bekend staat als het diamond-probleem of diamond-inheritance, wat een aanzienlijke uitdaging vormt in objectgeoriënteerde programmeertalen die meervoudige overerving ondersteunen.

Dit doet zich voor wanneer een subklasse erft van twee of meer classes, die op hun beurt erven van een gemeenschappelijke superklasse. De term diamond wordt gebruikt omdat het overervingsschema de vorm van een diamant heeft.

main.cpp


              1234567
            
class Base {};

class Derived1 : public Base {};

class Derived2 : public Base {};

class Diamond : public Derived1, public Derived2 {};

Het belangrijkste probleem bij diamond-inheritance is de ambiguïteit die het veroorzaakt. Omdat Diamond erft van zowel Derived1 als Derived2, die op hun beurt erven van Base, zijn er twee kopieën van Base binnen een object van Diamond. Dit kan leiden tot ambiguïteit.

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?
}

Oplossing voor het probleem

Het sleutelwoord virtual helpt om dit probleem te voorkomen. U kunt deze onduidelijkheid oplossen via virtuele overerving door het sleutelwoord virtual te gebruiken. Wanneer Diamond virtueel erft, zorgt C++ ervoor dat er slechts één kopie van de superklasse aanwezig is, zelfs als deze via verschillende paden meerdere keren wordt geërfd.

main.cpp


              1234567
            
class Base {};

class Derived1 : virtual public Base {};

class Derived2 : virtual public Base {};

class Diamond : public Derived1, public Derived2 {};

Opmerking

Probeer het ambiguïteitsprobleem in het vorige voorbeeld op te lossen door gebruik te maken van virtuele overerving.

Implementatie van Diamond Inheritance

Voor een effectieve implementatie van diamond inheritance, gebruik het virtual-keyword in de superklasse-declaratie binnen de tussenliggende classes. Zorg voor consistente toepassing van virtuele overerving in alle paden van de overervingshiërarchie en let op de volgorde van aanroepen van constructors en destructors.

Oplossen van ambiguïteiten

Een van de uitdagingen van meervoudige overerving is het omgaan met mogelijke ambiguïteiten bij leden met dezelfde namen.

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?
}

Als beide superklassen leden met dezelfde naam hebben, weet de subklasse mogelijk niet welke gebruikt moet worden. Om dergelijke ambiguïteiten op te lossen, kun je de scope-resolutie-operator (::) gebruiken om aan te geven van welke basisklasse je het lid wilt benaderen. Bijvoorbeeld:

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();
}

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 4. Hoofdstuk 5

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Cursusinhoud

C++ OOP

1. Fundamenten van OOP in C++

2. Constructors en Destructors

3. Overzicht van Encapsulatie

Introductie tot Encapsulatie Sleutelwoorden voor Toegangsmodificatoren Oefening Met Toegangsmodificatoren Accessor- en Mutatormethoden Segmentatie en Aggregatie Het Friend-sleutelwoord

4. Overzicht van Overerving

Introductie tot Overerving Toegangsmodificatoren bij Overerving Meervoudige Overerving Constructor en Destructor in Overerving Diamant-erfenis Het Final-sleutelwoord

5. Overzicht van Polymorfisme

Introductie tot Polymorfisme Virtual- en Override-trefwoorden Pure Virtuele Methode Operatoroverbelasting

Diamant-erfenis

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?
}

Oplossing voor het probleem

main.cpp


              1234567
            
class Base {};

class Derived1 : virtual public Base {};

class Derived2 : virtual public Base {};

class Diamond : public Derived1, public Derived2 {};

Opmerking

Probeer het ambiguïteitsprobleem in het vorige voorbeeld op te lossen door gebruik te maken van virtuele overerving.

Implementatie van Diamond Inheritance

Oplossen van ambiguïteiten

Een van de uitdagingen van meervoudige overerving is het omgaan met mogelijke ambiguïteiten bij leden met dezelfde namen.

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();
}

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 4. Hoofdstuk 5