problems with overloading the operator +

[dj_mike]

Hi,I am trying to add two objects of a class into a third one of the same class
for instance if class name kota and object name would be
kota A,B;

C=A+B;
but i am writting this to the kota.h
kota operator+(kota SA_1,kota SA_2);

and in the kota.cpp

kota kota:perator+(kota SA_1,kota SA_2)
{ kota C;
return C;
}

don't mind the rest of the algorithm the problem is that the compiler shows that

c:\windows\desktop\13331.rar\kota.h(23) : error C2804: binary 'operator +' has too many parameters

Error executing cll.exe.
Creating browse info file...

application.exe - 1 error(s), 0 warning(s)

please help otherwise how can i write so i can add the A+B(some values of them to C)
thanks.

[jwbarton]

Either write your operator+ as a member function of kota with 1 argument, or write it as a global function with 2 arguments.

Member:

kota kota::operator+( kota SA_2 ) const
{
kota C = ???; // add this and SA_2
return C;
}


Global:

kota operator+( kota SA_1, kota SA_2 )
{
kota C = ???; // add SA_ 1 and SA_2
return C;
}


Best regards,
John

[dj_mike]

i've tried both of those and it says the same thing again

Anyway this also what the C=A+B should do when it woulc be called through the main function

C.set(SA_2.exp_date.get_day(),SA_2.exp_date.get_month(),SA_2.exp_date.get_year());

//set(int,int,int);

i don't care about the algorithimic body i care about the compiler erros.

THanks for the help

[arunkumar_gona]

Overloading Binary operators:

prototype:
kota operator+(kota SA_1);
definition:
kota kotaerator+(kota SA_1)
{
kota C;
_________
_________
return C;
}

Overloading Binary operator using friend:

prototype:
friend kota operator+(kota SA_1,kota SA_2)
definition:
kota kota:perator+(kota SA_1,kota SA_2)
{
kota C;
=========
=========
return C;
}

This is supposed to work.
best of luck.

[sandodo]

I tested the following, they works:


1.----------------------------------
#ifndef _PT_CLASS_
#define _PT_CLASS_
class plustest {
//friend const plustest operator+(plustest& lhs, plustest& rhs);
public:
plustest(int nn)
{
n = nn;
};
plustest()
{
n = 10;
};
~plustest()
{
n = 0;
};
int n;
};


const plustest operator+(plustest& lhs, plustest& rhs);
#endif


#include "plustest.h"


const plustest operator+(plustest& lhs, plustest& rhs)
{
return plustest(lhs.n + rhs.n);
};

for this solution, i can also write the operator+ like the following:
const plustest operator+(plustest& lhs, plustest& rhs)
{
plustest pt;
pt.n = lhs.n + rhs.n;
return pt;
};

the const plustest operator+(plustest& lhs, plustest& rhs) can also be declared in class as friend as what i comment out.




2.------------------------------------------------------------
#ifndef _PT_CLASS_
#define _PT_CLASS_
class plustest {
public:
plustest(int nn)
{
n = nn;
};
plustest()
{
n = 10;
};
~plustest()
{
n = 0;
};

const plustest& operator+(plustest& rhs)
{
this->n = this->n + rhs.n;
return *this;
}

int n;
};

#endif

[Graham]

BTW - pass the arguments to the operator as const references rather than value args - it should be a bit more efficient:

kota operator+(const kota& lhs, const kota& rhs);

Also there's no point in a const value return from the function. i.e.

const kota& operator+(const kota&, const kota&)

makes sense, but

const kota operator+(const kota&, const kota&)

doesn't.