help with overloaded operators

i am writing a program that has to manipulate sparse polynomials, i have written all the linked list part of the program, but i am having troubles with writing some of the overloaded operators of (+) and of (-), any advice or help would be greatly appreciated, thanks:confused:

If sp is a sparce polynomial.

class sp
{

const sp& +operator( const sp& rsp )
{
// whatever you do to add sparse polynomials

return m1 + rsp.m1; //m1 (member one) plus the reference m1 ( member one) or whatever is done to add a sparce polynomial
}

sp sp1, sp2, sp3;

sp3 = sp2 + sp1; // sp2 would be the object calling the + operator and sp1 would be passed as the reference rsp

Yes, but:
1. Syntaxis of operator + is different ( '+' is at the end)
2. You may have problems returning a reference, as its object will be destroyed at the end of sp::operator+, the inline function may help, but do not count on that. Returning a real object & propper copy constructor is better, I think

class sp
{
sp(const sp&)
{
m1 = sp.m1; //or s'th like that
}

const sp operator+( const sp& rsp )
{
// whatever you do to add sparse polynomials

return sp(m1 + rsp.m1); //m1 (member one) plus the reference m1 ( member one) or whatever is done to add a sparce polynomial
}

sp sp1, sp2, sp3;

sp3 = sp2 + sp1; // sp2 would be the object calling the + operator and sp1 would be passed as the reference rsp

Sorry:

sp(const sp& other)
{
m1 = other.m1;
}

if you return an object adn not a reference, it doesn't have to be const.

Oh, yes, I just copied your code and get rid of reference. Later I saw that, but being const is not a problem, even is better, but operator + should be const I think:

const cp operator + (const cp& other) const
{
....
}

or

cp operator + (const cp& other) const
{
....
}

My bad. You're right on all counts. The return should be an object not a reference since operations creates a new object and it should be const since no operations should occur on what we've created, since the + operator does not create an l-value.

why can the returned object be an l-value?
suppose the class has a non-const method that evaluated a value and output it, why shouldn't we allow a syntax like
(sp1+sp2).EvalAndOutput() ?

since we create a temporary object, this object need not be const, and users of that object can use it anyway they like, including assigning to it, but that seems useles the copy constructor has some meaningful job.

All of the temporary objects are const according to ANSI C++ standard, so this would violate the stanadard, even if possible

Do you have any proof that "temporary objects are const according to ANSI C++ standard"?

Anyone lese have heard about it?
I can't see any reason why it should be that way.

Yes: "Thinking in C++, 2nd ed. Volume 1" by Bruce Eckel, see section: Operator Overloading, '+' operator; see also temporary objects
Now a little example:

struct TheClass
{
....
TheClass(int i);
};

void Func(TheClass& );

void main()
{
int i = 5;
Func(i); //The temporary object which is created here is const
//but the function takes non-const reference
//Some compilers generate warning, some do not
//accept it
}

well, I don't have the official ANSI standard, but from what I found in the net and my books about it, I think Eckel is wrong by saying (in page 284, first edition) that temporary objects are automatically const. I haven't seen any support for this.
As Scott Meyers explains in More Effective C++ (Item 19) there are tow main reasons fortemporary objects - when a type conversion occures to make function calls succeed, and when functions returns objects.
As mentioned in this item, there is a rule in the language that says that temporary objects cannot be assigned to a non-const references. As Meyers explains, this is because this probably not what the programmer wanted, because non-const references are meant to be changed, and by changing the reference, only the temporary object will be changed, and not the real data it was converted was.
This is why your example fails to compile in VC++ with the following error:
A reference that is not to 'const' cannot be bound to a non-lvalue

But that doesn't say that temporary objects are const. You can still call non-const methods on them.

Meyers do say (in Item 21 in the same book) that operator+() and operator*() should return a const object, because we don't want that objct to be used as l-value. It conforms to the general rule of "Do as the Ints do", meaning that your objects should behave similiar to the build-in types, and as they don't allow:
(3*4) = 5
so should your own object.

But, in two STL implementation I looked into (VC++ & ObjectSpace), the operator& of string (actually basic_string) returns a string, not a const string. (again, I don't know what the standard says about it, but I gues they both agree with it).

Conclusions?
I think temporary objects are not const (unless declared const). Generally, I tend to agree with Meyers, but here, errrr, I don't know.
The risk of someone using your object + return value as an l value:
(x1 + x2) = x3
seems unreal to me.
But the benefits can be substantial, if someone wants to call a non-const method on the result:
(x1+x2).Add(y).Print();

I am glad to see such responce in that forum.

Your answer is almost perfect.
As you, I haven't read the standard too.

But I am sure standard doesn't tell you the way you should declare the '+' operator.

Using VC++ for example is not a good idea: it is full of ANSI violations... But it also didn't compile the code:

As you see in my code 'i' is implicitly casted to 'TheClass': a temporary object of type struct TheClass is created. So if this object wasn't a const the file would be compiled well.

Lets suppose that code:

struct TheClass
{
int n;
TheClass(int i) : n(i){}
};

TheClass operator +(const TheClass& i, const TheClass& j)
{
return TheClass(i.n + j.n);
}

void Func(TheClass& );

void main()
{
int i = 5;
TheClass c1(i), c2(i);
Func(c1 + c2);
}


The code is not compiled by GNU C++, for that reason. (it is compiled by MSVC++ 6.0 & gives a warning in Borland C++ by the way... )

well, you do have a point ergarding why it is good to return a const object, but regarding the standard, we both don't know it, so I'm not sure GNU ++ is better then VC++.
According to VC++ message and to Meyers word, the standard disallows implicit conversion when the created temporary object is assigned to a non-const reference. That doesn't mean that all temporary object are const.

BTW,
If you used Func(TheClass(5)); - would GNU C++ eat it?


Another BTW,
The standard doesn't tell you the way you should declare THE '+' operator, but the sandard do have the STL, right? and it it has the declaration of the STL classes, right? So how is basic_string::operator+() defined there? form the two implementation I saw, it declared as returning a non-const basic_string.

Oh, yes STL is a standard....
Put on VC++ warings to 4-th level & try to compile program using it, the result is a flow of warings. If this is a standard...

So we both have the conclusion that it is possible to return a non-const value, but people rarely need it (unless you compile with GNU C++).

By the way you can try g++ under Windows environment as I do:
http://sources.redhat.com/cygwin/

I haven't yet saw an IDE even try to compete with VC++.
I admint I didn't try t oexplore all IDEs on unix X windows..., but I suspect even there, nothing compares VC++, espacially when it is with Visual Assist.

You are absolutely right about IDE. I am using VC++ with Visual Assist too.

What I gave you is just a command line tool which I use to compile small programs to check if they are compiled in other compilers (GNU C++ in that case).

VC++ doesn't support template members in template classes which I miss much :((

Well VC++ is the tool we have - for good and for bad.
My code should also be ocmpiled on various Unix platforms, so I need to conform to "some" standard.

Hey, how did you become a member?

i knew how to use the + to add the two operators when i used the this pointer and also the polynomial that i am adding, but i was wondering if i could get some help on the code on how to add the polynomials, the areas where i have stated not for sure what to put here is what i am having trouble with because i am not for sure how to keep going after i add the two like exponent polynomials and what to do if i find the place the polynomial is suppose to go but there is nothing to add to it, so it adds it self to the linked list, thanks:


{
ptrType cur; //pointer used to traverse linked list
bool found;

cur = head; //initialize cur to beginning of linked list
found = false;
//Searches efficiently for searchval
//Since the linked list is order, the search stops when if
//finds an element in the linked list which is greater than
//searchval
while((cur != NULL) && (!found) && (cur ->exponent >= searchval))
{
if(cur ->exponent == searchval)
{
found = true;
-----not for sure what to put here----
}
else
cur =cur->next;
}

if(!found)
----not for sure what to put here----
}

First about "member": I really do not know. I took the C++ test soon & in this test made 45 right answers (I tried to argue about 3 of the "wrong" answers, but I still didn't receive answer from the support of the site). Maybe this is the reason, or maybe the fact that I am too active in the forum...

Now about polynoms:
I am not sure what are you trying to achive, but if you try to add two polinoms, you should do this:
Merge the two list into resulting one (the one which you would return) & where you have elements with equal exponents add the two values.
Is this what you are trying to achieve?

yes that is what i am tring to achieve....

It would help if you'd put the decalaration of all variables and types in your code.
E.g. - what is searchVal and what is a linked-list item looks like?

here's a sample polynomial:

x^2 + 3x - 7

You could put this in the following form:

1x^2 + 3x^1 + (-7)x^0

so that in general each term in the statement is not a + sign conatains an int (coeffiicient) followed by a char (base) followed by the ^ symbol followed by an int (exponent). This information can be encapsulated in a struct with 3 data members like so:

struct Nomial
int coeficient
int base
int exponent

In this scenario the polynomial could then be a linked list with these structs as the data member and a pointer to struct the type itself. Your node for the linked list could look something like this:

struct Node
Nomial nomial
Node * next

Certainly, the member variables for Nomial could be more sophisticated if desired, but this should do for demonstration purposes.

Now lets say you have two polynomials

3x^1 + 8x^0 and 4x^1 + 2x^0

To add them you can just add the nodes of one list to the other to get

3x^1 + 8x^0 + 4x^1 + 2x^0

If you were doing this by hand you would then reduce the polynomial by adding like terms( adding the coeffiicients of nomials with the same base and exponent) to get this:

7x^1 + 10x^0

To do this with a linked list you need to look at each node compared to every other node in the list. If the base and exponent of the node (nomial) are the same then add the exponents of the two nodes and store it in one of the two nodes and delete the other node. To do this create two temp nodes, say one is stationaryNode and one is travelingNode. To start the search assign the root (or head) node of the list to stationary Node and then assign stationaryNode->next to travelingNode. If travelingNode is not NULL then compare the base and exponent of travelingNode to base and exponent of stationaryNode. If the are the same add the coefficient of travelingNode to the coefficient of stationaryNode and delete travelingNode. Continue until travelingNode is NULL. Then shift stationaryNode to stationaryNode->next and repeat the process. Continue until stationaryNode is NULL. When you are done the polynomial should be in reduced form.


I'll leave it up to you to convert the manual statements into code.

Lets say that base is the same: e.g. so called 'x'
This is a simple class that would give you what you need

class Polynom
{
......
public:
......
double operator () (double x);
....
const Polynom operator+(const Polynom& other) const;
or if you prefer:
Polynom operator+(const Polynom& other) const;
};

double Polynom::operator() (double x)
{
double dRet = 0;
ListElement* pCurrEl = list;
while (pCurrEl)//If this is a condition for end
{
dRet += pCurrEl->Data->Coeff*pow(x, pCurrEl->Data->Exp);
pCurrEl = pCurrEl->Next;
}

return dRet;
}

///Assume that this is a slow function
///Unless you have a reference counter of your
///List as more possibly a copy costructor will be called
const Polynom operator+(const Polynom& other) const
{
//I assume that the lists are sorted!!!!!!
Polynom polynom;
ListElement* pCurrElThis = list;
ListElement* pCurrElOther = other.list;

while (pCurrElThis && pCurrElOther)//if this is
//an end condition
{
if (pCurrElThis->Data->Exp == pCurrElOther->Data->Exp)
{
polynom.Add(pCurrElThis->Data->Exp,
pCurrElThis->Data->Coeff + pCurrElOther->Data->Coeff);
pCurrElThis = pCurrElThis->Next;
pCurrElOther = pCurrElOther->Next;
}
else if (pCurrElThis->Data->Exp < pCurrElOther->Data->Exp)
{
polynom.Add(pCurrElThis->Data->Exp,
pCurrElThis->Data->Coeff);
pCurrElThis = pCurrElThis->Next;
}
else if (pCurrElThis->Data->Exp > pCurrElOther->Data->Exp)
{
polynom.Add(pCurrElOther->Data->Exp,
pCurrElOther->Data->Coeff);
pCurrElOther = pCurrElOther->Next;
}
}
if (!pCurrElThis)
{
while (pCurrElOther)
{
polynom.Add(pCurrElOther->Data->Exp,
pCurrElOther->Data->Coeff);
pCurrElOther = pCurrElOther->Next;
}
}
else if (!pCurrElOther)
{
while (pCurrElThis)
{
polynom.Add(pCurrElThis->Data->Exp,
pCurrElThis->Data->Coeff);
pCurrElThis = pCurrElThis->Next;
}
}


assert(!pCurrElThis && !pCurrElOther);
return polynom;
}

//Of course check the code again, I just scraped it...