Operator Overloading - c++

Question

I'm Confused about a topic regarding operator overloading. See the following code:
#include <iostream>;
class Vectors {
public:
int x, y;
Vectors() {};
Vectors(int a,int b) {
x = a, y = b;
}
Vectors operator+(Vectors aso) {
Vectors brandNew;
std::cout << "ASO X " << aso.x << std::endl;
std::cout << "ASO Y " << aso.y << std::endl;
brandNew.x = brandNew.x + aso.x;
brandNew.y = brandNew.y + aso.y;
return (brandNew);
};
};
int main() {
Vectors v1(2,3);
Vectors v2(4,5);
Vectors v3;
v3 = v1 + v2;
std::cout << "Vector V3 X : " << v3.x << std::endl;
std::cout << "VECTOR V3 Y : " << v3.y << std::endl;
}
When I print aso.x, it y gives me 4 and 5. What I want to do is add both v1 and v2; meaning the x of v1 and v2, and the y of v1 and v2. Then, pass it into a Vectors object and return that object.
How do I accomplish that, given what I have above?

Answer 1

You probably meant
Vectors operator+(const Vectors& aso) {
Vectors brandNew;
std::cout << "ASO X " << aso.x << std::endl;
std::cout << "ASO Y " << aso.y << std::endl;
brandNew.x = x + aso.x;
brandNew.y = y + aso.y;
return (brandNew);
};
or
Vectors operator+(const Vectors& aso) {
Vectors brandNew(x + aso.x, y + aso.y);
std::cout << "ASO X " << aso.x << std::endl;
std::cout << "ASO Y " << aso.y << std::endl;
return (brandNew);
};
As from your comment
But about if there were three.
Chain the operators like
int main() {
Vectors v1(2,3);
Vectors v2(4,5);
Vectors v3(7,11);
Vectors v4;
v4 = v1 + v2 + v3;
std::cout << "Vector V4 X : " << v4.x << std::endl;
std::cout << "Vector V4 X : " << v4.y << std::endl;
}
See Live Demo

Answer 2

You can also use external operator+ :
class Vectors {
public:
int x, y;
Vectors() {};
Vectors(int a,int b) {
x = a, y = b;
}
friend Vectors operator+(const Vectors& v1, const Vectors& v2);
};
Vectors operator+(const Vectors& v1, const Vectors& v2) {
Vectors brandNew;
brandNew.x = v1.x + v2.x;
brandNew.y = v1.y + v2.y;
return (brandNew);
};
int main() {
Vectors v1(2,3);
Vectors v2(4,5);
Vectors v3;
v3 = v1 + v2;
std::cout << "Vector V3 X : " << v3.x << std::endl;
std::cout << "VECTOR V3 Y : " << v3.y << std::endl;
}

Answer 3

You haven't initialized the x and y members of brandNew. You'll get random results.
Vectors operator+(Vectors aso) {
Vectors brandNew;
std::cout << "ASO X " << aso.x << std::endl;
std::cout << "ASO Y " << aso.y << std::endl;
brandNew.x = x + aso.x;
brandNew.y = y + aso.y;
return (brandNew);
};

Answer 4

Your code creates the new Vectors object brandNew and then adds the values of it which are initialised to 0 to the values inside the Vectors object you passed in instead of the values in the current object. Which is why when you add v1 tov2 the result has the same values as those inside v2.
Replace
brandNew.x = brandNew.x + aso.x;
brandNew.y = brandNew.y + aso.y;
with
brandNew.x = x + aso.x;
brandNew.y = y + aso.y;

Answer 5

The correct definition of +operator is the following:
Vectors &operator+(const Vectors& aso)
{
std::cout << "ASO X " << aso.x << std::endl;
std::cout << "ASO Y " << aso.y << std::endl;
x = x + aso.x;
y = y + aso.y;
return (*this);
}
above code does not need temporary variable and also does not do unnecessary copy of parameters as is passed by reference.