CODEWITHSUNDEEP
c++classoperator-overloadingoverloading
ard_evon
ard_evon

Reputation: 191

Overloading operators outside of the class

So, i have a simple class:

class complex{

private:

    double a,b;

public:

    void setA(double a){ this->a=a; }

    void setB(double b){ this->b=b; }

    double getA(){ return a; }
    double getB(){ return b; }

    friend complex operator+(const complex&, const complex&);
};

And i have the actual overloaded operator here:

complex operator+(const complex& x, const complex& y){

    complex c;
    c.a=x.a+y.a;
    c.b=x.b+y.b;
    return c;
}

I must have the operator overloaded outside of the function. In order to have access to private variables (those also HAVE to be private) I befriended the class with the function. I don't know if that's correct way to do such things, but at least it works. I want to be able to add an integer to both members. In main():

complex a;
a.setA(2);
a.setB(3);
a+5;

Would result in having a.a=7 and a.b=8. Such overload inside the class is quite easy to make (Again, don't know if that's good solution, if not please correct me):

complex operator+(int x){

    this->a+=x;
    this->b+=x;
}

But I have no idea how to make it outside of the class because i can't use "this" pointer.

Upvotes: 0

Views: 116

Answers (1)

Pete Becker
Pete Becker

Reputation: 76235

The usual approach to this sort of problem is to have member functions that define the reflexive version of arithmetic operators and free functions that define the non-reflexive version, implemented with the reflexive version. No friend declarations needed. For example:

class complex {
public:
    complex& operator+=(const complex& rhs) {
        x += rhs.x;
        y += rhs.y;
        return *this;
    }
private:
    double x, y;
};

complex operator+(const complex& lhs, const complex& rhs) {
    complex result = lhs;
    result += rhs;
    return result;
}

Having a+5 change the value of a is unusual, but if that's really wha you want, make operator+(int) a member. However, users would typically expect that a+5 would leave a unchanged, and that a += 5 would modify a.

Upvotes: 3

Related Questions