3. Klassenmethode wird vom Compiler scheinbar ignoriert

Klassenmethode wird vom Compiler scheinbar ignoriert

  • *

    Hallo liebe Forengemeinde,

    ich habe in meiner Vektorklasse folgendes zu stehen:

    vector2d.h

    Vector2D deflectOff(const Vector2D&) const;             //deflects this vector off another vector
        void deflectOff(const Vector2D&);                       //dito changes this vector to the deflected one

    vector2.cpp

    Vector2D Vector2D::deflectOff(const Vector2D& vec) const
{
    return Vector2D(2 * vec.normalized() *this->dotProduct(vec.normalized()) - *this);
}
void Vector2D::deflectOff(const Vector2D& vec)
{
    *this = 2 * vec.normalized() * this->dotProduct(vec.normalized()) - *this;
}

    Folgender Aufruf funktioniert:

    Vector2D vec1(10,0);
    Vector2D vec2(5,-5);
    vec1.deflectOff(vec2);

    Was ich aber nicht verstehe, wieso er die Funktion mit Vector2D als Rückgabetyp nicht sieht:

    Vector2D vec1(10,0);
    Vector2D vec2(5,-5);
    Vector2D vec3;
    vec3 = vec1.deflectOff(vec2);

    ==> Fehler: Zuweisung von void!!! an Vector2D nicht möglich...er nimmt also die Funktion mit dem void Rückgabetypen

    Ich tippe auf ein ganz simplen Denkfehler und würde mich daher über einen Denkanstoß freuen 👍

    0
  • C

    Weil der Compiler da keinen Grund hat, gerade die const Methode zu wählen. Mach freie Funktionen draus und nenne sie "void deflect(..)" und "Vector2 deflected(..)". (Wobei ich die erste Funktion nur aus Performancegründen überhaupt anbieten würde.)

    0
  • *

    OK danke...Es funktioniert jetzt so wie du gesagt hast. Aber warum hat denn der Compiler keinen Grund die Funktion aufzurufen? Ich gebe ihm doch Grund genug^^

    0
  • C

    −BootLag−-BootLag- schrieb:

    Ich gebe ihm doch Grund genug^^

    Nein. Du darfst die Umgebung nicht als bekannt betrachten.
    Der Compiler sieht nur den Aufruf "vec.deflectOff(vec2)", und sucht eine passende Signatur - erst danach wird entschieden, ob der Rückgabewert auch zu vec3 passt. (Was er nicht tut, da void).
    Deswegen kann man auch nicht mit dem Rückgabetyp einer Funktion überladen, während die Parameter gleich sind.

    0
  • P

    Der Compiler sieht hier zwei Überladungen der Funktion: eine restriktive (const) und eine weniger restriktive. Da du die Funktion für ein non-const Objekt aufruft, sieht der Compiler keinen Grund, unnötig restriktiv zu sein und nimmt auch die nonconst-version.
    Überleg dir mal, wie das z.B. bei einem std::vector aussieht: den operator[] gibts auch in const und nonconst-Version. die const-Version liefert eine const-Referenz, die nonconst-version eine normale Referenz. Rufst du operator[] auf einem non-const vector auf, gehst du völlig zu recht davon aus, dass du das Resultat verändern kannst, d.h. du erwartest in so einem Fall, dass der Compiler bei einem non-const vector auch die non-const Variante aufruft.

    0
Log in to reply