[C++] How Operator Overloading Works

[welatiger]

Hi all;

I'm trying to learn about classes and objects, here is a program that demonstrate operator overloading, i cannot understand how it works, when i tried this:

//classes
#include <iostream>
using namespace std;
class CVector {
      public:
      int x,y;
      CVector(){};
      CVector(int,int);
      CVector operator + (CVector);
};

     CVector::CVector(int a,int b){
             x=a;
             y=b;
             }
     CVector CVector::operator+ (CVector param) {
             CVector temp;
             temp.x=x + param.x;
             temp.y=y + param.y;
             
             return(temp);
             }
int main(){
    CVector a (3,1);
    CVector b (1,2);
    CVector d (6,9);
    CVector c;
    c= a + b + d;
    cout<<c.x<<","<<c.y<<endl;
    system("pause");
    return 0;
}

the output as i expected is 10 and 12.

but when i tried this:

//classes
#include <iostream>
using namespace std;
class CVector {
      public:
      int x,y;
      CVector(){};
      CVector(int,int);
      CVector operator + (CVector);
};

     CVector::CVector(int a,int b){
             x=a;
             y=b;
             }
     CVector CVector::operator+ (CVector param) {
             CVector temp;
             temp.x=param.x + param.x;
             temp.y=param.y + param.y;
             
             return(temp);
             }
int main(){
    CVector a (3,1);
    CVector b (1,2);
    CVector d (6,9);
    CVector c;
    c= a + b + d;
    cout<<c.x<<","<<c.y<<endl;
    system("pause");
    return 0;
}

the output is 12,18, what is the difference between the two programs?

 

[Ibix]

I suspect you've just made a typo - but let's go through the whole process, in case it's an understanding error.

Operator overloading let's you write methods that get called when you write mathematical operations. This means that if you have a class C, and you define an operator+ method, you can then use the + operator to do maths with instances of class C. If c1 and c2 are instances of class C, you can write:
C c3=c1+c2;
In languages that do not permit operator overloading, you would have to define a method called (for example) add, and use something like:
C c3=c1.add(c2);
The only advantage to operator overloading is that the result is easier to read for a human. In fact, when the compiler sees
C c3=c1+c2;
it knows it should actually do:
C c3=c1.operator+(c2);
So, your line
c=a+b+d;
is equivalent to
c=a.operator+(b).operator+(d);

Can you trace through the two method calls to see what's happening in your modified code?

[Hint: 12=6+6, 18=9+9]

 

[AlephZero]

The difference is that

temp.x=param.x + param.x;
temp.y=param.y + param.y;

sets "temp" to "param" + "param".
That's what you got. Your output is twice the value of "d".

The first program means the same as

temp.x=this.x + param.x;
temp.y=this.y + param.y;

which is what you would expect the "+" operator to mean.

 

[welatiger]

Thank You for your reply, it seems very complicated subject, i have two more questions:

(1) when i declare an array like this:
int a[8];
is that mean that the compiler take a space in memory of (4 bytes x 8 =32 bytes), since int is 4 bytes.

(2) is the pointer take a place in memory, i mean is this statements are true:
int *a,*b;
b=&a;

Thank You for Your Concern

 

[DrGreg]

(1) when i declare an array like this:
int a[8];
is that mean that the compiler take a space in memory of (4 bytes x 8 =32 bytes), since int is 4 bytes.

Yes, provided an int is 4 bytes. For some compilers, or compiler options, an int could be a different number of bytes.

(2) is the pointer take a place in memory, i mean is this statements are true:
int *a,*b;
b=&a;

No. You have declared both a and b to be pointers to integers, but in the second line, b would need to be a pointer to a pointer to an integer. You'd have to declare it as

int *a, **b;
b = &a;