How do I most efficiently return multiple values from an overloaded operator? (C++)

I have a class "complex" that contains a Real and an Imaginary value. I'm trying to ov开发者_如何学编程erload the + operator so I can add real to real and imaginary to imaginary, but I'm banging my head against a wall here.

In the function, I can get the values easy. Returning them however, is a bitch.

My plan is to overload the '=' operator, too, so I can go

complex a, b, c;

(set a and b)

c = a + b;

then have a+b return a complex, then have complex c equal the complex returned by a+b

Any opinion on whether that's a viable path?

Any opinion on whether it can be done easier?

Return them as a complex! e.g.

const complex operator+(const complex &a, const complex &b)
{
    return complex(a.re + b.re, a.im + b.im);
}

You shouldn't need to overload operator=; the compiler will generate one for you that does an element-by-element copy, which will probably suffice for a complex class.

I'm not sure I understand the problem. Do you have a complex class?

struct complex
{
    complex(float real, float imag) :
    real(real), imag(imag)
    {}

    // first make the mutating version
    complex& operator+=(const complex& rhs)
    {
        real += rhs.real; 
        imag += rhs.imag;

        return *this;
    }

    float real, imag;
};

// then use that for the non-mutating version
complex operator+(complex lhs, const complex& rhs)
{
    lhs += rhs;
    return lhs;
}

This is, of course, just an exercise; we have std::complex.

What's wrong with overloading the + operator:

complex operator+(const complex& a, const complex& b) const {
    return complex(a.real + b.real, a.imag + b.imag);
}

And the operator=() similarly? (but the compiler give you this by default)

complex& operator=(const complex& a) {
    real = a.real;
    imag = a.imag;
    return *this;
}

It is viable but there is already complex class in standard library. Reuse it or at least have a look how the operator overloading is done there.