signatur einer Funktion

breathe_easy

Was genau versteht man unter der Signatur einer Funktion z.B. in Bezug auf Polymorphismus?

breathe_easy

Firefighter

Signatur ist: Funktionsname und Parameter...
ändert sich bei einer Signatur die Anzahl/Art der Parameter so spricht man von Übnerladung d.h. wenn man mehr als eine Funktion mit dem gleichen namen, gleichen Rückgabewert aber unterschiedlicher Art von Parameter...

so sollte es ungefähr sein.wenn nicht bitte korrigieren

Quellcode

ändert sich Methode der Unterklasse in der Signatur bei gleichbleibendem Namen so spricht man von Überladen...

in Bezug auf Polymorphie:

Die Methode der Unterklasse mit gleichem Namen und gleichen Parametern in der Signatur (Parameterliste), aber unterschiedlichem Funktionsrumpf nennt man in Bezug auf Polymorphie polymorphe Methode. Dh. sie überschreibt beim Aufruf die Methode der Basisklasse, wenn diese von einem Basisklassenobjekt aufgerufen wird. zuvor muss jedoch die Methode in der Basisklasse virtual deklariert worden sein.

Bsp:

class Basisklasse
{
          // virtual ist das Schluesselwort
  public: virtual void ausgabe(int i, float f, char* s) = 0; // Rein virtuelle Methode
};

class Unterklasse: public Basisklasse
{
          // Signatur = Signatur der Basisklasse (macht aber was Anderes)
  public: void ausgabe(int i, float f, char* s){...};
};

main()
{
  // Erstellen eines zeigers auf einen BasisklassenObjekt
  Basisklasse *BasisklassenZeiger = new Unterklasse;

  // Zugriff auf Methode ausgabe
  // Hierbei wird dynamisch festgelegt, welche Methode der Basisklasse
  // mit der Methode der Unterklasse überschrieben wird
  BasisklassenZeiger->ausgabe();

  // Speicherplatz freigeben
  delete BasisklassenZeiger;
}

Hoffe, dass ich dir ein bisschen helfen konnte.

princess

überladung hat aber nichts mit vererbung zu tun... also ja man kann es da verwenden aber zb. du baust dir einen eigenen datentyp. zB ein rational objekt. das willst du auch ausgeben wollen, so musst du den right-shift-operator (<<) ÜBERLADEN.
das heißt du definierst den operator<< neu. so das dein compiler weiß wie du zB cout<< rat_obj; benutzen kannst..

bsp:

class rational{
[...]
public:
  void print_on(std::ostream& os) const;
[...]
};

std::ostream& 
operator<<(std::ostream& os, rational const& rhs);

Simon2

princess schrieb:

überladung hat aber nichts mit vererbung zu tun...

Stimmt natürlich ... aber nicht wenige verwenden versehentlich Überladung, wenn sie eigentlich "Vererbung" (bzw. "virtual-Polymorphie") verwenden wollen.

Beispiel:

Version 1.0:

// A.h
struct A { virtual void machwas(void); }

// B.h
struct B : A { void machwas(void); }

// Simon2.cpp
void simonsFunc(A* a) {
   a->machwas();
}

int main() {
   A a;
   B b;
   simonsFunc(&a);
   simonsFunc(&b);
   return 0;
}

// AndererUser.cpp
void andererFunc(B* b) {
   b->machwas();
}

int main() {
   B b;
   andererFunc(&b);
   return 0;
}

In Version 1.2 braucht "andererUser" nun einen integer-Parameter in der Implementation von B::machwas()

// B.h
struct B : A { void machwas(int); }

// AndererUser.cpp
void andererFunc(B* b) {
   b->machwas(3);
}

-> Hoppla! Nun funktioniert Simons Code nicht mehr, weil hier Überladung zuschlägt statt (wie vorher) "overriding".

Ist natürlich ein sehr verinfachtes Beispiel ... aber derartigen Code habe ich schon öfter gesehen.

Gruß,

Simon2.