Polymorphie

freakC++

mmh...vielleicht hab ich mich auch komisch ausgedrückt. Noch ein Versuch:

Wenn sich während der Laufzeit ein Programm zwischen Methoden entscheiden kann, nennt man das Polymorphie. Ich hab mich nochmal begoogelt und immer das gleiche gelesen. Immer werden zwei Klassen vereinbart, wobei die eine die andere als Vorfahrtyp hat. Beide Klassen jedoch haben eine Methode mit dem gleichen Namen.

Da es sich normalerweise um eine frühe Bindung handelt, kann sich das Programm nicht zwischen den beiden "entscheiden" was zur Folge hat, dass eine sozusagen "vergessen" wird. Erst das Wort virtual bringt alles wieder ins Lot!

Naja...vielleicht bin ja immer noch falsch, aber dann wäre ich wahrscheinlich doch auf eine Erklärung von euch angewiesen, da ich dann ja wohl einige Tutorials missverstanden habe.

Vielen Dank für eure Hilfe
lg, freakC++

witte

Die Idee ist das das enthaltende Objekt die Methode entscheidet. Spiel damit mal rum:

#include <iostream>

//---------------------------------------------------------------------------
class A1
{
public:
    virtual void foo(){ std::cout << "A1" << std::endl; }
};

class A2
{
public:
    void foo(){ std::cout << "A2" << std::endl; }
};

class B1 : public A1
{
    void foo(){ std::cout << "B1" << std::endl; }
};

class B2 : public A2
{
    void foo(){ std::cout << "B2" << std::endl; }
};

#pragma argsused
int main(int argc, char* argv[])
{
    A1 *p1 = new A1();
    p1->foo();
    delete p1;

    A1 *p2 = new B1();
    p2->foo();
    delete p2;

    A2 *p3 = new A2();
    p3->foo();
    delete p3;

    A2 *p4 = new B2();
    p4->foo();
    delete p4;

    return 0;
}

freakC++

Ah, das ist sehr gut, witte. Wenn ich nun das Wórt virtual vor der ersten Methodenvereinbarung (foo) weglassen, dann funktioniert das Programm zwar auch, aber es wird immer nur auf die Ursprungmethode zugegriffen, da es sich um eine statische Methode handelt, oder??

Ich hab dazu auch ein Beispiel:

Unit1.h

class TNeu
{
 public:
  void Zeige (void);
  virtual String Zahl (void) {return 100;};
  TNeu ();
};

class TNeuer : public TNeu
{
 public:
  String Zahl (void) {return 200;};
  TNeuer ();
};

Unit 1.cpp

//---------------------------------------------------------------------------
TNeu::TNeu ()
{
}
//---------------------------------------------------------------------------
TNeuer::TNeuer () : TNeu ()
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
 Neu1 = new TNeu ();
 Neuer1 = new TNeuer ();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 Neu1->Zeige();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
 Neuer1->Zeige();
}
//---------------------------------------------------------------------------
void TNeu::Zeige (void)
{
 Form1->Label1->Caption = "Zahl = " + Zahl ();
}

WEnn ich nun wieder das Wörtchen virtual in der Headerdatei weglasse, wird in b eiden Fällen 100 ausgegebn. Sonst 200....

Ich denke, dass ich es kapiert habe. Dennoch muss ich noch ein bisschen tüfteln, wie man am ersten Post von mir (Close ()) sieht....

Vielen Dank für eure Hilfe
lg, freakC++

Unter Polymorphie versteht man (zumindest bei C++) zwei Konzepte. Wikipedia behandelt das sicher ausführlicher, aber kurz und knapp kann ich´s ja mal eben anschneiden.

Funktionen mit gleichen Namen und gleicher Parameteranzahl, die allerdings unterschiedliche Parametertypen verwenden:

void func( int iParam )
{
}

void func( double dParam )
{
}
[cpp]

2) Klassen, die von einer gemeinsamen Basisklasse ableiten, die mindestens eine virtuelle Methode besitzt, die in der ableitenden Klasse implementiert wird:

[cpp]
class Shape
{
   std::string Name_;

public:
   Shape( const std::string Name ) :
      Name_( Name )
   {
   }

   virtual ~Shape()
   {
   }

   // virtuelle Methode
   virtual double area() const = 0;

   // Namen zurückgeben
   std::string& name()
};

class Triangle : public Shape
{
public:
   Triangle() : Shape( "Triangle" )
   {
   }

   // Implementation der virtuellen Methode
   double area() const;
};

class Rectangle : public Shape
{
public:
   Rectangle() : Shape( "Rectangle" )
   {
   }

   // Implementation der virtuellen Methode
   double area() const;
};

int main
{
   // heterogener Container mit Pointer auf Shapes
   std::vector<Shape*> Shapes;

   // Rechteck und Dreieck einfügen
   Shapes.push_back( new Rectangle() );
   Shapes.push_back( new Triangle() );

   for( unsigned int uiIndex = 0; uiIndex < Shapes.size(); ++uiIndex )
   {
      // Fläche jedes Shape ausgeben
      std::cout << "Fläche von "
                << Shapes[uiIndex].name()
                << ": " <<
                << Shapes[uiIndex].area()
                << std::endl;
   }
}

Die Idee sollte zumindest erkennbar sein.

Gruß,
Doc

PS:
Ich find´s gut, dass sich jemand um grundlegende Konzepte bemüht und nicht nur solange irgendwas in den Editor hackt, bis der Compiler zufrieden ist und ungefähr das rauskommt, was man haben will.

akari

DocShoe schrieb:

Funktionen mit gleichen Namen und gleicher Parameteranzahl, die allerdings unterschiedliche Parametertypen verwenden:
void func( int iParam )
{
}

void func( double dParam )
{
}

Eigentlich wird das als Überladen bezeichnet, nicht als Polymorphie.

Naja man kann Überladen auch einer der möglichen Anwendungen der Polymorphie bezeichnen. Dann müßte aber deine Liste von mehr Punkte beinhalten.

bis bald
akari

Braunstein

Zu diesem Thema gab es doch im C++ Forum einen richtig langen Thread.
http://www.c-plusplus.net/forum/viewtopic-var-t-is-216663.html

freakC++

Hallo,
danke für den Link, Braunstein. Den Thread hab ich gar nicht gefunden...
Ich denke aber, dass Überladen und Polymorphie zwar irgendwie ähnlich sind, aber dennoch nicht zusammenfassbar sind, oder??

Vielen Dank für eure Hilfe
lg, freakC++

akari schrieb:

Eigentlich wird das als Überladen bezeichnet, nicht als Polymorphie.

Naja man kann Überladen auch einer der möglichen Anwendungen der Polymorphie bezeichnen. Dann müßte aber deine Liste von mehr Punkte beinhalten.

bis bald
akari

Das sind zwei unterschiedliche Paar Schuhe. Polymorphismus wird hier durch Überladung erreicht.

akari

Hallo

Ja das ist ja auch meine Meinung, das Überladen und Polymorphie zwei verschiedene Sachen sind. Das wird ja schon alleine dadurch deutlich das eine virtuelle Methode nicht gleichzeitig auch überladen werden kann.

bis bald
akari

freakC++

Hallo,
sry akari...du hattest es bereits gesagt, aber ich wollte es einfach nochmal untermauern
lg, freakC++

Im allgemeinen ist OOP Laufzeitpolymorphie gemeint, wenn beim Programmieren von Polymorphie gesprochen wird. Bei Laufzeitpolymorphie hast du ein Objekt der Basisklasse und rufst immer die gleiche Methode mit den gleichen Parametern auf, aber das verhalten ist zur Laufzeit unterschiedlich, weil die Methode von abgeleiteten Klassen überschrieben werden kann.

Beim überladen rufst du eigentlich immer ne andere Funktion auf, weil die Funktion durch die Parameter bestimmt wird, aber es ist halt der gleiche Funktionsname. Also hast du beim gleichen Funktionsnamen unterschiedliches verhalten.

http://lexikon.gulli.com/Polymorphie_(Programmierung)