Implementierungen von Funktionen aufheben und ersetzen?

Hi,

ist es möglich das ich eine Funktion in einer Klasse implementiere und diese Funktion später nachträglich ungültig mache und durch eine andere ersetze. Die ersetze funktion soll dann nur noch benutzt werden und die alte solls nicht mehr geben.

Also sowas:

class foo
{
public:
    foo () : wert(0) {}
    ~foo () {}

    int irgendwas ();

    int wert;
};

    // Dies ist der alte
int foo::irgendwas ()
{
    return wert*2;
}

    // Dies ist der neue
int foo::irgendwas ()
{
    return wert*wert;
}

Wenn das geht, bzw. nicht geht. geht das auch mit instanzen? Also:

class foo
{
public:
    foo () : wert(0) {}
    ~foo () {}

    int irgendwas ();

    int wert;
};

    // Dies ist der alte
int foo::irgendwas ()
{
    return wert*2;
}

foo bar, foobar;
    // Das ist irgendwas(); von bar
int bar::irgendwas ()
{
    return 0;
}

    // Das ist irgendwas(); von foobar
int bar::irgendwas ()
{
    return 10;
}

Geht sowas ohne vererbung? Wenn ja: WIE? Ansonsten: Wie kann ich es machen das ich nicht für jede Instanz eine klasse vererben muss und dann "irgendwas();" überladen muss?

Caipi

'#' schrieb:

Hi,

ist es möglich das ich eine Funktion in einer Klasse implementiere und diese Funktion später nachträglich ungültig mache und durch eine andere ersetze. Die ersetze funktion soll dann nur noch benutzt werden und die alte solls nicht mehr geben.

Soetwas lässt sich (sofern ich dich verstanden habe) mit virtuellen Funktionen realisieren. (Allerdings funktioniert dies nur im Zusammenhang mit Vererbung.)
Also wenn du die Klasse base hast mit folgender Deklaration:

class base
{
   protected:
     int value;
   public:

     base(int v) : value(v) {}
     virtual int do_something()
     {
        return value *= 2;
     }
     virtual ~base() {};
};

Wenn du jetzt eine Klasse (z.B. derived) von Base erben lässt, kannst du das Verhalten von do_something() anpassen.

Beispiel:

class derived : public base
{
    public:
       derived(int v) : base(v) { }

       virtual int do_something()
       {
           return value *= value;
       }
};

Mithilfe von Basisklassenzeigern schaffst du nun ein einheitliches Interface, dessen Funktionalität davon abhängt, worauf gezeigt wird.

Beispiel:

int main()
{
   base* obj = new base(9);
   obj->do_something(); // hier wird base::do_something() aufgerufen.

   delete obj;
   obj = new derived(9);
   obj->do_something(); // hier wird derived::do_something() aufgerufen.
   delete obj;
}

Wenn das geht, bzw. nicht geht. geht das auch mit instanzen? Also:

class foo
{
public:
    foo () : wert(0) {}
    ~foo () {}

    int irgendwas ();

    int wert;
};

    // Dies ist der alte
int foo::irgendwas ()
{
    return wert*2;
}

foo bar, foobar;
    // Das ist irgendwas(); von bar
int bar::irgendwas ()
{
    return 0;
}

    // Das ist irgendwas(); von foobar
int bar::irgendwas ()
{
    return 10;
}

Bist du dir sicher, dass hier kein Designfehler vorliegt?
Das ist wie, wenn du Zwei Bäume erzeugst, deren Verhalten nicht davon abhängt, welchen Typ sie haben (d.h. ihr Verhalten hängt nicht vom "Baum sein" ab) sondern welchen Namen sie haben (d.h. der eine Baum soll z.B. zum Mond fliegen können, weil er bsp: "superflieger" heißt, wogegen der zweite Baum das ganz gewöhnliche Leben eines Baumes führen soll, weil er eben nur "die Fichte vom Hans" heißt...)

Gruß Caipi

finix

'#' schrieb:

Geht sowas ohne vererbung? Wenn ja: WIE? Ansonsten: Wie kann ich es machen das ich nicht für jede Instanz eine klasse vererben muss und dann "irgendwas();" überladen muss?

Google: "Strategy Pattern"

Mathias

Klar geht sowas auch ohne Vererbung. Du kannst dies zum Beispiel mit Objekten modellieren.
Du definierst dir in dem Objekt, das die Funktion, die du austauschen möchtest einen Zeiger auf eine Klasse X. Wenn der Zeiger ungleich NULL ist wird eine Funktion dieses Objekts ausgeführt, ansonsten der lokale Code.

Also sogesehen geht das nur mit Funktionspointern, gell?