Friend operator saving problem
For some reason my operands are not storing the values in the private class, but they are all friends of the class... Where did I go wrong on this code?
Code:class Diamond{ friend bool operator+(Diamond); friend int size(Diamond); public: Diamond(); Diamond(int); private: int size_of; }; bool operator+(Diamond d) //expand_size { int tmp; tmp = d.size_of + 2; if (tmp < 40 && tmp > 1) { d.size_of = tmp; return true; } else return false; }
That is a very uncommon usage of the operator+. Operator+ is a binary operator. That means that it should be a member function that takes a single argument, or even better, a non-member friend that takes two arguments to be added together.
Assuming for a moment that you know what you are doing, or for some reason you have to do it that way, and you only made typos above, the reason nothing is updated is that you pass the Diamond object to the operator+ function by value. That means a copy is made, so when you set d.size_of equal to tmp, you are changing the value inside the temporary copy.
By the way, a common way of implementing operator++ is:
Code:class Diamond{ Diamond& operator++(); const Diamond operator++(int); public: Diamond(); Diamond(int); private: int size_of; }; Diamond& Diamond::operator++() //expand_size { int tmp = size_of + 2; if (tmp < 40 && tmp > 1) { size_of = tmp; } return *this; } const Diamond Diamond::operator++(int) //expand_size { Diamond oldValue(*this); ++(*this); return oldValue; }
Or, the way I like to write it
Code:const Diamond Diamond::operator++(int) { return ++Diamond(*this); }
Except yours won't work properly xErath.
When you doit should return a copy of the value before it is incremented. Yours makes a copy and then increments that without ever incrementing the actual object.Code:obj++;
If you don't believe lets test:
output:Code:#include <iostream> class Foo { int x_; public: Foo() : x_(0) {} Foo(const Foo & f) : x_(f.x_) {} const int & x() const { return x_; } Foo operator++(int) // post increment { return ++Foo(*this); } Foo& operator++() // pre increment { x_ += 1; return *this; } friend std::ostream& operator<<(std::ostream &o, const Foo &f) { return o<<f.x_; } }; int main() { Foo f; std::cout<<f<<std::endl; f++; std::cout<<f<<std::endl; ++f; std::cout<<f<<std::endl; }
Now if we change the function to:Code:0 0 1
we get the proper output of:Code:Foo operator++(int) // post increment { Foo temp(*this); ++*this; return temp; }
Code:0 1 2Just like operator- there is a binary and an unary version. Normally the unary just returns a copy a copy of the object:Operator+ is a binary operator.
Of course it could easily be made a non friend, non member function.Code:Foo Foo::operator+() const { return *this; }
Last edited by Thantos; 11-10-2004 at 12:39 AM.
Ahh yes, thank you.Originally Posted by Thantos
Well.. maybe... But I always write my +, -, *, / operator like that, using +=, -=, *=, /=. The ++ and -- operator simply change the class where there called and not some returned object, so I don't get any problems with those.
eg:Thanks by the info anywayCode:Class& Class::operator+(Class& cc){ return Class(*this) +=cc; }
1) The parameter to that function should be const.Code:Class& Class::operator+(Class& cc){ return Class(*this) +=cc; }
2) You are returning a reference to a local variable
3) The function itself should be const
4) It could be a non member non friend function as such:
Remind me not to use your codeCode:Class operator+(const Class &c1, const Class &c2) { return Class(c1) += c2; }
1) I know all that
2) I wrote that code in the post editor
3) No special need to be outside the class.
4) It was only an example...
I'll just have to remind not to be that much distracted when postingCode:Class Class::operator+(const Class& cc) const{ return Class(*this)+=cc; }
1) Then why didn't you do it correctly?
2) So did I
3) No special need to be inside the class
