Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
27.04.2007, 15:26 Uhr
~barnadani
Gast

Hallo Leute,
Ist das Kode unten gultig? Mit g++ 4.1.2 kompiliert es ohne Fehlermeldung, und produziert
B::f(1)
B::f(2)
B::extra()
wie erwartet, das bedeutet aber nicht unbedingt, das es gultig ist. Danke!

-----------
Kode:

C++:

#include <iostream>
using namespace std;

class A
{
public:
    A &f(int i) { cerr<<"A::f("<<i<<")"<<endl; return *this; }
};

class B : public A
{
public:
    B &f(int i) { cerr<<"B::f("<<i<<")"<<endl; return *this; }
    void extra() { cerr<<"B::extra()"<<endl; }
};

int main()
{
    B b;
    b.f(1).f(2).extra();
    return 0;
}

Bearbeitung von 0xdeadbeef:

Jupp, die Benutzung der CPP-Tags wurde vergessen.

Nächstes mal bitte selbst machen.

Dieser Post wurde am 27.04.2007 um 16:00 Uhr von 0xdeadbeef editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
27.04.2007, 15:39 Uhr
mischa
Fragender

hallo erstmal
A() B() sind bei dir doch Konstruktoren und ich habe gelernt das Konstruktoren und Destruktoren keinen Rückgabewert haben. Ich wundere mich warum der Code keinen Fehler erzeugt

--
Latein Unterricht ist die spätere Rache der Römer an den Germanen.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
27.04.2007, 15:53 Uhr
~barnadani
Gast

Ich habe keine Konstruktore geschrieben, und ich nutze sie gar nicht.
Ich rufe die Funktion f(int) (ich hatte einen langeren Namen geben sollen, die sichtbar ist...)

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

003
27.04.2007, 15:59 Uhr
ao

(Operator)

f1 und f2 geben jeweils eine Instanz vom Typ B zurück, bzw. eine Referenz darauf, die zum Aufrufen weiterer Methoden (f2 bzw. extra) benutzt wird. Ich kann nichts Ungültiges entdecken.

ao

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

004
27.04.2007, 16:03 Uhr
stephanw
localhorst

Naja, immerhin übersetzt es ja.

Wenn Du f(int) eigentlich überschreiben willst, musst Du sie als "virtual" deklarieren. So wie jetzt ist es zwar syntaktisch korrekt, aber unglücklich und gefährlich, weil es für den Menschen verwirrend ist.
--
Reden ist Schweigen und Silber ist Gold.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

005
27.04.2007, 16:10 Uhr
~barnadani
Gast

Auch wenn es virtual ist: muss die Funktion, die die Alte uberschreibt, nicht dasselbe return-type haben?
A::f(int) gibt A& zuruck, B::f(int) [die A::f(int) uberschreibt] gibt B& zuruck.

Aha, vielleicht etwas gefunden:

C++:

class A
{
public:
    virtual A &f(int i) { cerr<<"A::f("<<i<<")"<<endl; return *this; }
};

class B : public A
{
public:
    double f(int i) { cerr<<"B::f("<<i<<")"<<endl; return 1.0; }
    void extra() { cerr<<"B::extra()"<<endl; }
};

Dieses Kode kompiliert nicht mehr:

Zitat:

proba.C:13: error: conflicting return type specified for virtual double B::f(int)
proba.C:7: error: overriding virtual A& A::f(int)

Also das return-type muss nicht dasselbe sein, aber ahnlich (A& und B& sind 'ahnlich', da B von A stammt)

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

006
27.04.2007, 16:20 Uhr
0xdeadbeef
Gott
(Operator)

Joa, richtig ist der Code so schon. A::f wird halt nicht benutzt.

Anders ist das natürlich, wenn du jetzt noch

C++:

A &a = b;
a.f(1).f(2); //.extra geht hier nicht, Rückgabewert ist vom Typ A

dahinter schreibst.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

007
27.04.2007, 17:08 Uhr
stephanw
localhorst

Zitat von ~barnadani:

Auch wenn es virtual ist: muss die Funktion, die die Alte uberschreibt, nicht dasselbe return-type haben?
A::f(int) gibt A& zuruck, B::f(int) [die A::f(int) uberschreibt] gibt B& zuruck.

Prinzipiell muss der Rückgabewert natürlich gleich sein. Einzige zulässige Ausnahme ist genau Dein Beispiel. Allgemein:

C++:

class A {};
class B : public A {};

struct Base
{
  virtual A* getObject();
};

struct Derived : public Base
{
  // ueberschreibt Base::getObject() und ist legal,
  // wenn B öffentlich von A erbt
  virtual B* getObject();
};

--
Reden ist Schweigen und Silber ist Gold.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: