3. Funktionsaufloesung bei ueberladenen funktionen

Funktionsaufloesung bei ueberladenen funktionen

  • ?

    mal ne kleine frage
    ich hab ne klasse mit 2 funktionen

    void   fun(int);
  double fun(const int);

    wenn ich nun

    int i;
 double val=fun(i);

    machen will finded mein compiler natuerlich das void fun(int) passend
    wie bring ich dem dazu das double fun(const i); besser ist?

    double val=fun(static_cast<const int>(i));

    bringt nix und i darf nicht kopiert werden, denn im original ist i nicht integer sondern ne menge mehr.
    zZ ist meine Loesung so

    const int &ri=i;
 double val=fun(i);
    0
  • S

    void foo(int)
    und
    void foo(const int)

    haben dieselbe signatur!
    was du willst geht nicht.

    uU suchst du template funktionen?

    0
  • ?

    tschuldigung aber
    mit
    const int &ri=i;
    double val=fun(ri);
    wird die double fun(const int); Funktion aufgerufen,
    meiner meinung nacht ist (const int) != (int) und das beachtet der compiler da schon

    0
  • H

    meiner meinung nacht ist (const int) != (int) und das beachtet der compiler da schon

    Du liegst mit deiner Meinung hier falsch.

    Nocheinmal: Es gibt aus Sicht von C++ bei Funktionsparametern *keinen* Unterschied zwischen value und cons value.

    void Func(int a){}
void Func(const int a) {}

    Das ist zweimal *exakt* die selbe Funktion Func. Es handelt sich also um zwei Definitionen der *selben* Funktion. Und das ist laut ODR illegal. Kein konformer Compiler darf das übersetzen.

    Das ganze macht auch viel sinn: Da das Argument *by value* übergeben wird ist es sowieso implizit const. Es kann nicht von der Funktion verändert werden, da es die Funktion nie erreicht. Lediglich *der Wert* wird übergeben. Nicht das Objekt selbst. Ein const bringt also absolut überhaupt keinen Informationsgewinn.

    Das ist nicht zu verwechseln mit:

    void Func(int& a){}
void Func(const int& a) {}

    Das sind in der Tat zwei verschiedene Überladungen der Funktion Func.

    wie bring ich dem dazu das double fun(const i); besser ist?

    Die Antwort sollte nach dem oben gesagten klar sein: Gar nicht.

    bringt nix und i darf nicht kopiert werden

    const hat nix mit kopieren zu tun. Bei einer *by value* Übergabe wird *immer* kopiert. Was du scheinbar suchst sind Referenzparameter.

    void Func(int& a){}
void Func(const int& a) {}

...
int i;
Func(i);     // ruft Func(int&) auf
Func(2);     // ruft Func(const int&) auf
Func(2.0)    // ruft Func(const int&) auf
Func(const_cast<const int&>(i)); // ruft Func(const int&) auf
    0
  • ?

    noch mal tschuldigung
    es waren natuerlich uebergebene referenzen
    und wie im text habe ich auch beim casten das "&" vergessen

    0
Anmelden zum Antworten