[C++] Operator+= not found

[Gamebuster]

Om een lang verhaal kort te maken:

Deze code werkt:

C++:

Vertex2D<float> incr = tween.getTween();
progress += incr;

Op dezelfde plek, deze code niet:

C++:

progress += tween.getTween();

main.cpp:19: error: no match for 'operator+=' in 'progress += Tween<T>::getTween() [with T = Vertex2D<float>]()'

Mijn vraag: waarom werkt het bovenste wel en het onderste niet?

Volledige main.cpp:

C++:

#include <iostream>
#include "EasedTween.cpp"
#include "TickCounter.hpp"
#include "Vertex2D.cpp"

int main(int argc, char * const argv[]) {
    const TickCount duration = 20;
    Vertex2D<float> mov(100.0f, 50.0f);
    
    Tween<Vertex2D<float> > tween(mov, duration);
    Vertex2D<float> progress(0.0f, 0.0f);
    
    std::cout << "float:\n";
    for(int i=0;i<=duration;i++)
    {
        std::cout << "[" << progress.getX() << ", "
                         << progress.getY() << "]\n";
        tween.tick();
        progress += tween.getTween();
    }
    
    return 0;
};

Vertex2D (deel van de implementatie, niet compleet)

C++:

template<class T>
Vertex2D<T> Vertex2D<T>::operator+=(Coordinate2D<T> &v2d)
{
    this->x += v2d.getX();
    this->y += v2d.getY();
    return *this;
};

template<class T>
Vertex2D<T> Vertex2D<T>::operator+=(T t)
{
    this->x += t;
    this->y += t;
    return *this;
};

Tween::getTween()

C++:

template <class T>
T Tween<T>::getTween()
{
    TickCountProgress tickProgress = this->getTickProgress();
    if(tickProgress < 1.0f)
    {
        T tween = this->getTweenAtProgress(tickProgress);
        tween -= this->tweenDone;
        this->tweenDone += tween;
        return tween;
    }
    else if(!this->isFinished()) {
        T tween = this->tweenTotal - this->tweenDone;
        this->tweenDone = this->tweenTotal;
        return tween;
    }
    else {
        return T(0);
    }
};

[ Voor 20% gewijzigd door Gamebuster op 18-08-2010 19:19 ]

[HMS]

Het verschil is Tween<Vertex2D<float>> en Vertex2D<float>, misschien kan je hier iets mee?

Werkt dit?

C++:

progress += (Vertex2D<float>)tween.getTween();

~edit: Disclaimer: ben geen C++ guru

[ Voor 10% gewijzigd door HMS op 18-08-2010 19:22 ]

[Gamebuster]

HMS schreef op woensdag 18 augustus 2010 @ 19:21:
Het verschil is Tween<Vertex2D<float>> en Vertex2D<float>, misschien kan je hier iets mee?

Werkt dit?

C++:

progress += (Vertex2D<float>)tween.getTween();

~edit: Disclaimer: ben geen C++ guru

tween.getTween geeft al een Vertex2D<float> terug, dat is het vreemde. Zie ook de declaratie:
Tween<Vertex2D<float> > tween(mov, duration);

::getTween geeft, ondanks zijn misleidende naam, het type T binnen de template terug, wat in de declaratie een Vertex2D<float> is. ::getTween geeft dus een Vertex2D<float> terug.

Die typecast ervoor zetten had in ieder geval geen enkel bij-effect:

C++:

progress += (Vertex2D<float>)tween.getTween();

C++:

progress += (Vertex2D<float>)(tween.getTween());

Beide dezelfde error:
main.cpp:19: error: no match for 'operator+=' in 'progress += Tween<T>::getTween() [with T = Vertex2D<float>]()'

[ Voor 13% gewijzigd door Gamebuster op 18-08-2010 19:27 ]

[Mijzelf]

Ik neem aan dat het de bedoeling is dat de operator

C++:

template<class T> 
Vertex2D<T> Vertex2D<T>::operator+=(Coordinate2D<T> &v2d)

zou moeten worden gebruikt? Mogelijk heeft de compiler een probleem om een referentie naar een anonieme tussenvariable mee te geven. Probeer het eens met

C++:

template<class T> 
Vertex2D<T> Vertex2D<T>::operator+=(Coordinate2D<T> v2d)

[Gamebuster]

Mijzelf schreef op woensdag 18 augustus 2010 @ 19:38:
Ik neem aan dat het de bedoeling is dat de operator

C++:

template<class T> 
Vertex2D<T> Vertex2D<T>::operator+=(Coordinate2D<T> &v2d)

zou moeten worden gebruikt? Mogelijk heeft de compiler een probleem om een referentie naar een anonieme tussenvariable mee te geven. Probeer het eens met

C++:

template<class T> 
Vertex2D<T> Vertex2D<T>::operator+=(Coordinate2D<T> v2d)

Coordinate2D<T> is een abstract type, moet een pointer ernaar gebruiken. Verder moet het ook kunnen rekenen met andere implementaties van Coordinate2D<T>.

C++:

template<class T>
class Coordinate2D
{
public:
    virtual T getX() = 0;
    virtual T getY() = 0;
    
    bool operator==(Coordinate2D<T> &);
    bool operator!=(Coordinate2D<T> &);
    
    ~Coordinate2D(){};
};

C++:

/** An implementation of Coordinate2D<T> */
template <class T>
class Vertex2D: public Coordinate2D<T>
{
protected: 
    
    /** The first vertex dimension. */
    T x;
    
    /** The second vertex dimension. */
    T y;
    
public:
    
    Vertex2D();
    Vertex2D(T t);
    Vertex2D(T x, T y);
    
    virtual T getX();
    virtual T getY();
    
    Vertex2D<T> operator+(Coordinate2D<T> &);
    Vertex2D<T> operator-(Coordinate2D<T> &);
    Vertex2D<T> operator*(Coordinate2D<T> &);
    Vertex2D<T> operator/(Coordinate2D<T> &);
    
    Vertex2D<T> operator+=(Coordinate2D<T> &);
    Vertex2D<T> operator-=(Coordinate2D<T> &);
    Vertex2D<T> operator*=(Coordinate2D<T> &);
    Vertex2D<T> operator/=(Coordinate2D<T> &);
    
    Vertex2D<T> operator+(T);
    Vertex2D<T> operator-(T);
    Vertex2D<T> operator*(T);
    Vertex2D<T> operator/(T);
    
    Vertex2D<T> operator+=(T);
    Vertex2D<T> operator-=(T);
    Vertex2D<T> operator*=(T);
    Vertex2D<T> operator/=(T);
};

[ Voor 51% gewijzigd door Gamebuster op 18-08-2010 19:49 ]

[DroogKloot]

Je mist een

C++:

Vertex2D<T>& operator += (const Vertex2D<T>& v) {
    // ...
    return *this;
}

[Gamebuster]

DroogKloot schreef op woensdag 18 augustus 2010 @ 19:51:
Je mist een

C++:

Vertex2D<T>& operator += (const Vertex2D<T>& v) {
    // ...
    return *this;
}

C++:

template<class T>
Vertex2D<T>& Vertex2D<T>::operator+=(Coordinate2D<T> &v2d)
{
    this->x += v2d.getX();
    this->y += v2d.getY();
    return *this;
};

main.cpp:19: error: no match for 'operator+=' in 'progress += TweenHandler<T>::getTween() [with T = Vertex2D<float>]()'

C++:

template<class T>
Vertex2D<T>& Vertex2D<T>::operator+=(const Coordinate2D<T> &v2d)
{
    this->x += v2d.getX();
    this->y += v2d.getY();
    return *this;
};

Vertex2D.cpp:110: error: passing 'const Coordinate2D<float>' as 'this' argument of 'T Coordinate2D<T>::getX() [with T = float]' discards qualifiers
Vertex2D.cpp:111: error: passing 'const Coordinate2D<float>' as 'this' argument of 'T Coordinate2D<T>::getY() [with T = float]' discards qualifiers

Gaat weer lekker

Wat ik ook doe, het aantal errors neemt alleen maar enorm toe

[ Voor 62% gewijzigd door Gamebuster op 18-08-2010 20:02 ]

[Mijzelf]

DroogKloot schreef op woensdag 18 augustus 2010 @ 19:51:
Je mist een

C++:

Vertex2D<T>& operator += (const Vertex2D<T>& v) {
    // ...
    return *this;
}

Dat mag dan ook een

C++:

 Vertex2D<T> operator+=(const Coordinate2D<T> &);

zijn, lijkt me. Dan moet

C++:

virtual T getX();

ook const worden, trouwens.

[Gamebuster]

C++:

template<class T>
class Coordinate2D
{
public:
    virtual T getX() const = 0;
    virtual T getY() const = 0;
    
    bool operator==(Coordinate2D<T> &coord) const
    {
        return this->getX() == coord.getX()
            && this->getY() == coord.getY();
    };
    
    bool operator!=(Coordinate2D<T> &coord) const
    {
        return this->getX() != coord.getX()
            || this->getY() != coord.getY();
    };
    
    ~Coordinate2D(){};
};

C++:

template <class T>
class Vertex2D: public Coordinate2D<T>
{
protected: 
    
    /** The vertex dimensions. */
    T x, y;
    
public:
    
    Vertex2D(): x(0), y(0) {};
    Vertex2D(T t): x(t), y(t) {};
    Vertex2D(T x, T y): x(x), y(y) {};
    
    virtual T getX() const {return this->x;};
    virtual T getY() const {return this->y;};
    
    Vertex2D<T> operator+(const Coordinate2D<T> &coord){return (*this)+=coord;};
    Vertex2D<T> operator-(const Coordinate2D<T> &coord){return (*this)-=coord;};
    Vertex2D<T> operator*(const Coordinate2D<T> &coord){return (*this)*=coord;};
    Vertex2D<T> operator/(const Coordinate2D<T> &coord){return (*this)/=coord;};
    
    Vertex2D<T> operator+=(const Coordinate2D<T> &coord)
    {
        this->x += coord.getX();
        this->y += coord.getY();
        return *this;
    };
    
    Vertex2D<T> operator-=(const Coordinate2D<T> &coord)
    {
        this->x -= coord.getX();
        this->y -= coord.getY();
        return *this;
    };
    
    Vertex2D<T> operator*=(const Coordinate2D<T> &coord)
    {
        this->x *= coord.getX();
        this->y *= coord.getY();
        return *this;
    };
    
    Vertex2D<T> operator/=(const Coordinate2D<T> &coord)
    {
        this->x /= coord.getX();
        this->y /= coord.getY();
        return *this;
    };
    
    Vertex2D<T> operator+(const T t){return (*this)+=t;};
    Vertex2D<T> operator-(const T t){return (*this)-=t;};
    Vertex2D<T> operator*(const T t){return (*this)*=t;};
    Vertex2D<T> operator/(const T t){return (*this)/=t;};
    
    Vertex2D<T> operator+=(const T t)
    {
        this->x += t;
        this->y += t;
        return *this;
    };
    
    Vertex2D<T> operator-=(const T t)
    {
        this->x -= t;
        this->y -= t;
        return *this;
    };
    
    Vertex2D<T> operator*=(const T t)
    {
        this->x *= t;
        this->y *= t;
        return *this;
    };
    
    Vertex2D<T> operator/=(const T t)
    {
        this->x /= t;
        this->y /= t;
        return *this;
    };
};

Werkt nu

Bedankt, allen.

Wat een vervelende taal is C++ toch soms

edit:
compacte versie neergeplakt

[ Voor 62% gewijzigd door Gamebuster op 18-08-2010 20:19 ]

[Jarno]

Check dit leesvoer eens..

Edit; Er zit ook een dik dictaat bij, dat verder borduurt op C..

[ Voor 31% gewijzigd door Jarno op 18-08-2010 20:26 ]

[Gamebuster]

Jarno schreef op woensdag 18 augustus 2010 @ 20:12:
Check dit leesvoer eens..

Bookmarked.

Ik ben inderdaad nog lerende, net begonnen aan C++ vanuit PHP en Java.

Heb ook al boek aangeschaft (en gebruik 'm ook daadwerkelijk) en lees aardig wat tut's door voor informatie over wat de beste manieren zijn om iets te bereiken.

[ Voor 27% gewijzigd door Gamebuster op 18-08-2010 20:21 ]

[NC83]

Het getter probleem dat je had komt doordat de parameter die je invoert const is en niet const gedeclareerde methoden niet op een const object mogen worden aan geroepen. Google eens op const correctness.

Een andere goeie hulp bron is http://www.cplusplus.com/ als naslagwerk

[ Voor 15% gewijzigd door NC83 op 18-08-2010 23:16 ]

[.oisyn]

NC83 schreef op woensdag 18 augustus 2010 @ 23:12:
Het getter probleem dat je had komt doordat de parameter die je invoert const is en niet const gedeclareerde methoden niet op een const object mogen worden aan geroepen.

Dat is op zich waar maar niet wat hier van toepassing is. Het probleem is dat getTween() een rvalue teruggeeft, en rvalues kunnen niet binden aan non-const references (en de paramater van operator+= verwachtte juist een non-const ref).

[ Voor 7% gewijzigd door .oisyn op 19-08-2010 09:59 ]

[Gamebuster]

NC83 schreef op woensdag 18 augustus 2010 @ 23:12:
Het getter probleem dat je had komt doordat de parameter die je invoert const is en niet const gedeclareerde methoden niet op een const object mogen worden aan geroepen. Google eens op const correctness.

Een andere goeie hulp bron is http://www.cplusplus.com/ als naslagwerk

cplusplus is goed ja

Ik gebruik hoofdzakelijk cplusplus.com, "C++ Cookbook" en Apple developer documentation van O Reilly

.oisyn schreef op donderdag 19 augustus 2010 @ 09:58:
[...]

Dat is op zich waar maar niet wat hier van toepassing is. Het probleem is dat getTween() een rvalue teruggeeft, en rvalues kunnen niet binden aan non-const references (en de paramater van operator+= verwachtte juist een non-const ref).

Ik heb werkelijk geen flauw idee waar dit over gaat

[ Voor 28% gewijzigd door Gamebuster op 19-08-2010 19:25 ]

[.oisyn]

De termen "lvalue" en "rvalue" zijn afgeleid van assignment expressies, zoals bijv. "a = 5". Een lvalue is iets waar je een waarde aan kunt assignen, meestal een variabele, en een rvalue is een waarde die je kunt assignen. Vandaar ook l- en rvalue, omdat ze resp. links en rechts van de = staan. "a" is dus de lvalue, en "5" is een rvalue. Je kunt niet doen "5 = a", want 5 is nou eenmaal geen variabele. Hetzelfde geldt voor het resultaat van een functieaanroep. In beginsel kan iets als "foo() = 4" ook niet. Een lvalue is natuurlijk ook een rvalue - je kunt 'm assignen, en daarom mag iets als "a = b" ook. Maar andersom niet.

En dan heb je C++, die referenties ondersteunt. Als een expressie in C++ resulteert in een type dat geen non-const referentie is, dan is dat in feite een rvalue. Als foo() bijvoorbeeld een int retourneert, dan is dat dus een rvalue. Daarentegen, lvalues zijn expressies die een non-const referentie naar een object teruggeven.

Nou kun je in principe wel een referentie verkrijgen naar een rvalue, maar alleen als deze const is. Wat er dan onder water gebeurt is dat er tijdelijk een object wordt aangemaakt waar de referentie naar wijst. In C++ kun je dus wel dit doen:

C++:

const int & a = 34;

Hoewel 34 eigenlijk geen object is dat een referentie heeft, kan er wel tijdelijk een int object worden aangemaakt met die waarde, om daar vervolgens de referentie van te nemen. Het is expres niet toegestaan om een non-const referentie te verkrijgen, omdat je dan evt zou kunnen denken dat je de waarde aan kunt passen. Maar "34" kun je nou eenmaal niet aanpassen, dat is gewoon 34. Uiteraard kun je redeneren dat je het tijdelijke int object wel aan zou kunnen passen, maar dat zou mogelijk verwarring met zich meebrengen. Vandaar dus de regel "an rvalue cannot bind to a non-const reference".

In jouw code gebeurde in feite exact hetzelfde. Je hebt een operator +=, die een non-const referentie verwacht, en een functie die een object teruggeeft. Versimpeld zag dat er zo uit:

C++:

int foo()
{
    return 42;
}

void bar(int & i)
{
    // ...
}

int main()
{
    bar(foo())
}

Maar, het resultaat van foo() is een rvalue, en bar() verwacht een non-const reference. Resultaat: compile error. Verander je bar() zo dat hij een const ref verwacht (omdat je 'm toch niet aanpast), dan mag het wel.

[Gamebuster]

.oisyn schreef op donderdag 19 augustus 2010 @ 19:42:


De termen "lvalue" en "rvalue" zijn afgeleid van assignment expressies, zoals bijv. "a = 5". Een lvalue is iets waar je een waarde aan kunt assignen, meestal een variabele, en een rvalue is een waarde die je kunt assignen. Vandaar ook l- en rvalue, omdat ze resp. links en rechts van de = staan. "a" is dus de lvalue, en "5" is een rvalue. Je kunt niet doen "5 = a", want 5 is nou eenmaal geen variabele. Hetzelfde geldt voor het resultaat van een functieaanroep. In beginsel kan iets als "foo() = 4" ook niet. Een lvalue is natuurlijk ook een rvalue - je kunt 'm assignen, en daarom mag iets als "a = b" ook. Maar andersom niet.

En dan heb je C++, die referenties ondersteunt. Als een expressie in C++ resulteert in een type dat geen non-const referentie is, dan is dat in feite een rvalue. Als foo() bijvoorbeeld een int retourneert, dan is dat dus een rvalue. Daarentegen, lvalues zijn expressies die een non-const referentie naar een object teruggeven.

Nou kun je in principe wel een referentie verkrijgen naar een rvalue, maar alleen als deze const is. Wat er dan onder water gebeurt is dat er tijdelijk een object wordt aangemaakt waar de referentie naar wijst. In C++ kun je dus wel dit doen:

C++:

const int & a = 34;

Hoewel 34 eigenlijk geen object is dat een referentie heeft, kan er wel tijdelijk een int object worden aangemaakt met die waarde, om daar vervolgens de referentie van te nemen. Het is expres niet toegestaan om een non-const referentie te verkrijgen, omdat je dan evt zou kunnen denken dat je de waarde aan kunt passen. Maar "34" kun je nou eenmaal niet aanpassen, dat is gewoon 34. Uiteraard kun je redeneren dat je het tijdelijke int object wel aan zou kunnen passen, maar dat zou mogelijk verwarring met zich meebrengen. Vandaar dus de regel "an rvalue cannot bind to a non-const reference".

In jouw code gebeurde in feite exact hetzelfde. Je hebt een operator +=, die een non-const referentie verwacht, en een functie die een object teruggeeft. Versimpeld zag dat er zo uit:

C++:

int foo()
{
    return 42;
}

void bar(int & i)
{
    // ...
}

int main()
{
    bar(foo())
}

Maar, het resultaat van foo() is een rvalue, en bar() verwacht een non-const reference. Resultaat: compile error. Verander je bar() zo dat hij een const ref verwacht (omdat je 'm toch niet aanpast), dan mag het wel.

Ik heb het 2x moeten lezen, en toen viel er een 2-euro-munt. Bedankt voor je uitleg

[farlane]

.oisyn schreef op donderdag 19 augustus 2010 @ 19:42:
.. verhaal ..

Mag die in de FAQ?

[Robtimus]

Gamebuster schreef op woensdag 18 augustus 2010 @ 20:07:

C++:

    Vertex2D<T> operator+(const Coordinate2D<T> &coord){return (*this)+=coord;};
    Vertex2D<T> operator-(const Coordinate2D<T> &coord){return (*this)-=coord;};
    Vertex2D<T> operator*(const Coordinate2D<T> &coord){return (*this)*=coord;};
    Vertex2D<T> operator/(const Coordinate2D<T> &coord){return (*this)/=coord;};

Dus als ik ergens "c = a + b" neerzet dan wordt a aangepast en is c achteraf niets anders dan een pointer / reference naar hetzelfde object als a? Is dat echt de bedoeling?

[.oisyn]

Nou ja "c" is een kopie van de nieuwe "a", maar je hebt helemaal gelijk dat "a" nu wordt aangepast . Sowieso moet de method dus const zijn, dan had dit niet eens kunnen gebeuren (en je wilt immers ook const vectors op kunnen tellen), maar nog liever implementeer je dergelijke operators buiten de klasse (zodat je gebruik kunt maken van implicit conversions, mochten die van toepassing zijn.

Als we dan toch bezig zijn:

C++:

    Vertex2D(T t): x(t), y(t) {}; 

Die wil je waarschijnlijk explicit hebben. Of wil je dat een float impliciet converteerbaar is naar een Vector2D<float>? Let erop, je kunt dan ook doen "v + 5" ofzo. Wiskundig gezien klopt daar natuurlijk niets van

En de hele naam "Vertex" lijkt me ongelukkig gekozen. Een vertex is een hoekpunt (zoals van een polygoon), en kan wel meer properties hebben dan alleen de coordinaten, en ermee kunnen rekenen lijkt me daarom nutteloos. Vector2D lijkt me een beter. Een daadwerkelijke vertex heeft dan een Vector2D als property (onder de naam "position" oid)

@NMe: sure

[ Voor 86% gewijzigd door .oisyn op 20-08-2010 15:27 ]

[NMe]

farlane schreef op vrijdag 20 augustus 2010 @ 14:21:
[...]

Mag die in de FAQ?

Als .oisyn dat goed vindt.