no match for operator+ error with operator overloading

Question

I'm going through the gameinsitute's c++ programming course and there is an example for operator overloading and i'm constantly getting a

main.cpp|20|error: no match for ‘operator+’ in ‘v + w’

and i have no idea where the problem is.

main.cpp

// main.cpp

#include "Vector3.h"
#include <iostream>

using namespace std;

int main()
{
    float coords[3] = {1.0f, 2.0f, 3.0f};
    Vector3 u;
    Vector3 v(coords);
    Vector3 w(-5.0f, 2.0f, 0.0f);

    cout << "u = ";    u.print();
    cout << "v = ";    v.print();
    cout << "w = ";    w.print();
    cout << endl;

    u = v + w; // this gives the error
    cout << "v + w = ";
    u.print();
    cout << endl;

    v.normalize();
    cout << "unit v = ";
    v.print();
    cout << "v.length() = "<< v.length() << endl;
    cout << endl;

    float dotP = u * w; // this also gives error
    cout << "u * w = " << dotP << endl;

    float* vArray = v.toFloatArray();

    cout <<
          "[0] = " << vArray[0] << ", "
          "[1] = " << vArray[1] << ", "
          "[2] = " << vArray[2] << endl <<endl;

    cout << "Input vector..." << endl;
    Vector3 m;
    m.input();
    cout << "m = ";
    m.print();

    return 0;
}

Vector3.h

#ifndef VECTOR3_H
#define VECTOR3_H

#include <iostream>

class Vector3
{
public:

    // constructors
    Vector3();
    Vector3(float coords[3]);
    Vector3(float x, float y, float z);
    Vector3(const Vector3& vec);

    // methods
    float  length();
    void    normalize();
    float* toFloatArray();
    void    print();
    void    input();

    // operators
    Vector3 operator=(const Vector3& rhs);
    Vector3 operator+(const Vector3& rhs) const;
    Vector3 operator-(const Vector3& rhs) const;
    float  operator*(const Vector3& rhs) const;
    Vector3 operator*(float scalar) const;

    // fields
    float mX;
    float mY;
    float mZ;
};

#endif // VECTOR3_H

Vector3.cpp

#include "Vector3.h"
#include <cmath>
#include <iostream>

using std::cout;
using std::cin;

Vector3::Vector3()
{
    mX = 0.0f;
    mY = 0.0f;
    mZ = 0.0f;
}

Vector3::Vector3(float coords[3])
{
    mX = coords[0];
    mY = coords[1];
    mZ = coords[2];
}

Vector3::Vector3(float x, float y, float z)
{
    mX = x;
    mY = y;
    mZ = z;
}

Vector3::Vector3(const Vector3& vec)
{
    mX = vec.mX;
    mY = vec.mY;
    mZ = vec.mZ;
}

float Vector3::length()
{
    return sqrt(mX*mX + mY*mY + mZ*mZ);
}

void Vector3::normalize()
{
    float len = length();
    mX /= len;
    mY /= len;
    mZ /= len;
}

float* Vector3::toFloatArray()
{
    return &mX;
}

void Vector3::print()
{
    cout << "<" << mX << ", " << mY << ", " << mZ << "> \n";
}

void Vector3::input()
{
    cout << "Enter x: ";
    cin >> mX;
    cout << "Enter y: ";
    cin >> mY;
    cout << "Enter z: ";
    cin >> mZ;
}

//operators

Vector3 Vector3::operator=(const Vector3& rhs)
{
    Vector3 vTemp;
    vTemp.mX = rhs.mX;
    vTemp.mY = rhs.mY;
    vTemp.mZ = rhs.mZ;

    return vTemp;
}

Vector3 Vector3::operator+(const Vector3& rhs) const
{
    Vector3 sum;
    sum.mX = mX + rhs.mX;
    sum.mY = mY + rhs.mY;
    sum.mZ = mZ + rhs.mZ;

    return sum;
}

Vector3 Vector3::operator-(const Vector3& rhs) const
{
    Vector3 dif;
    dif.mX = mX - rhs.mX;
    dif.mY = mY - rhs.mY;
    dif.mZ = mZ - rhs.mZ;

    return dif;
}

float Vector3::operator*(const Vector3& rhs) const
{
    float dotP = mX*rhs.mX + mY*rhs.mY + mZ*rhs.mZ;

    return dotP;
}

Vector3 Vector3::operator*(float scalar) const
{
    Vector3 p;
    p.mX = mX * scalar;
    p.mY = mY * scalar;
    p.mZ = mZ * scalar;

    return p;
}

Thank you for your help in advance!

Answer 1

There's nothing wrong with your operator+ - it's your operator= which is wrong and leads to the result of the operator+ not doing what you think it's doing. Fixing that will sort out your problem.

Vector3 Vector3::operator=(const Vector3& rhs)
{
    mX = rhs.mX;
    mY = rhs.mY;
    mZ = rhs.mZ;
    return *this;
}

Answer 2

on a side note, there's a problem with some of these overloads, you are returning local refernce. I'm sorry that this is not an answer and I might get downvote for that, but still:

Take for example operator=. It should be

Vector3& Vector3::operator=(const Vector3& rhs)
{
  this->mX = rhs.mX;
  this->mY = rhs.mY;
  this->mZ = rhs.mZ;
  return (*this);
}

otherwise you are returning a local reference that will be garbage once this function exits. Same problem is with operator +-. As for operator* you are doing a dot product, which is not the same as vector multiplication. For that I suggest writing a function called dot() which takes another vector and performs a dot product between self and 2nd vector

Alternatively you should use Eigen library

If you can provide us how do you compile your code, maybe we can help