[C++] C#-like override in C++

[Mnstrspeed]

Waarschijnlijk weer een beginnersvraag, maar googlen heeft tot nu toe weinig tot niets opgeleverd

Ik wil de method van een base class volledig vervangen door een gelijknamige method in mijn derived class, zodat wanneer ik vanuit de constructor van de base class de method aanroep, hij de method van de derived class pakt en niet die van de base class. In C# kon dit altijd makkelijk via de override modifier.

C#:

using System;

public class Base
{
    public Base()
    {
        Console.WriteLine("Base.Base");
        this.Update();
    }

    protected virtual void Update()
    {
        Console.WriteLine("Base.Update");
    }
}

public class Derived : Base
{
    public Derived()
    {
        Console.WriteLine("Derived.Derived");
    }

    protected override void Update()
    {
        Console.WriteLine("Derived.Update");
        base.Update();
    }

    public static void Main()
    {
        Derived d = new Derived();
    }
}

De output hierbij is dus

code:

Base.Base
Derived.Update
Base.Update
Derived.Derived

Hoe zou ik in C++ een vergelijkbare werking kunnen krijgen?

Alvast bedankt

[Zoijar]

Erg lang zal je niet gezocht hebben Zoek maar op "C++ virtual function"

[Mnstrspeed]

Ook op gezocht, ja, maar niet wat ik zoek.

C++:

#include <iostream>
#define Out(x) std::cout << x << std::endl;

class Base
{
public:
    Base()
    {
        Out("Base::Base");
        Update();
    }

    virtual void Update()
    {
        Out("Base::Update");
    }
};

class Derived : public Base
{
public:
    virtual void Update()
    {
        Out("Derived::Update");
    }
};

int main()
{
    Derived d;
    std::cin.get();

        return 0;
}

Met de output:

Base::Base
Base::Update

Wat dus niet de bedoeling is, aangezien ik juist Derived::Update vanuit Base::Base wil aanroepen

[Zoijar]

Dat is omdat je het in een constructor doet. Eerst wordt Base volledig geinstantieerd, voordat de constructor van Derived verder wordt uitgevoerd. Op het moment dat de costructor voor Base hier dus draait, bestaat Derived nog niet, en wijst Update() naar Base::Update. zie ook http://www.artima.com/cppsource/nevercall.html

Wat C# hier doet lijkt me erg riskant...

[ Voor 6% gewijzigd door Zoijar op 19-07-2009 16:42 ]

[Stray]

Indien je in de derived class een functie definieerd met dezelfde signature zal is hij overriden.
Alleen moet je in dit geval opletten met polymorphisme en eigenlijk is het een bad programming practice om non-virtual member-methods te overriden.
Indien je zelf de code van de base class kan aanpassen meot je de functie virtual maken, zoals Zoilar al heeft aangegeven.

[Mnstrspeed]

Bedankt voor de opheldering, nu zie ik het ook

In mijn echte base class riep ik bovendien ook nog eens Base::Update aan ipv gewoon Update, waardoor hij automatisch al naar de base method ging. Logisch dus dat het niet werkte

Dit is dus de goede, niet-riskante versie van hoe het zou moeten?

C++:

#include <iostream>
#define Out(x) std::cout << x << std::endl;

class Base
{
public:
    Base()
    {
        Out("Base::Base");
    }

    void Create()
    {
        Update();
    }

    virtual void Update()
    {
        Out("Base::Update");
    }
};

class Derived : public Base
{
public:
    void Update()
    {
        Out("Derived::Update");
    }
};

int main()
{
    Derived d;
    d.Create();

    std::cin.get();
}

[Zoijar]

Dat zou volgens mij wel moeten werken, ja. Als je met inheritance werkt in C++ kan je wel beter met pointers of references werken, anders kan je problemen krijgen met kopieen. Zoek maar op "object slicing"

[farlane]

Stray678 schreef op zondag 19 juli 2009 @ 16:39:
Indien je zelf de code van de base class kan aanpassen meot je de functie virtual maken, zoals Zoilar al heeft aangegeven.

Maar dat was hier niet de fout, de fout was dat een virtual functie in een constructor/destructor van een base class niet doet wat de TS wil.