4

I have the following code to overload the + and += operators respectively for the class Date. The operator + was successfully overloaded, and it will take an integer n and increase Date objects by n days. This is done by applying the next_day function n times.

inline Date operator+(Date d, int n) { for(char j=1; j<=n; j++){ d=d.next_day(d); } return d; } inline Date operator+=(Date d, int n) { Date p=d+n; return p; }

Having overloaded the + operator, I'm using it to define the overloading of += as well. But although no errors occurred in compilation, when I use the overloaded += it doesn't seem to have any effect.

Here's my main.cpp:

#include <iostream> #include "Date.h" using namespace std; int main() { Date Initialday = Date (12,1,2012); Initialday+=1; cout <<"Next day = "<< Initialday <<endl; return 0; }

Running the main function still gives me 12/1/2012 instead of 12/2/2012. What am I doing wrong? Note: I've already overloaded << to output Date objects in a readable format, so I don't think that's the issue.

Improve this question
0

2 Answers 2

Reset to default
6

The simple fix is to take your Date object in by reference, modify it, and return it by reference. That's the expected behavior of operator+=.

inline Date& operator+=(Date &d, int n) { d = d + n; return d; }

However, to implement operator+= in terms of operator+ is backwards. It should be the other way around. operator+= should act on the members of the object, changing them directly. Then operator+ should be implemented in terms of that:

inline Date& operator+=(Date& lhs, int rhs) { ... // code here to modify lhs directly return lhs; } inline Date operator+(Date lhs, int rhs) { return lhs += rhs; }
Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

thanks so much! I agree, it is somewhat backwards - but in this case both += and + seemed equally straightforward because I had already defined the function next_day and thought I might as well use it. and I guess as a beginner it seemed more intuitive to me to define + first!
just for learning's sake, may I ask why the following wouldn't work? inline Date& operator+=(Date &d, int n) { Date p = d + n; return p; } It gives me an error message saying that local variable p was automatically returned. What does this mean?
@PatrickJane: The issue is not really that one is more or less straight-forward than the other. The issue is mainly performance. operator+ takes two objects and makes a completely separate object from them. But there is no reason that operator+= should need to construct a new object. By implementing operator+= in terms of operator+, you are copying the object, modifying the copy, then copying the copy back into the original object. That's two unnecessary copies, when all it needs to do is just modify the original object.
@PatrickJane: The problem with that implementation is, firstly, that you are returning a reference to a local object (p). When the function ends, p is destroyed, so the returned reference is invalid. Secondly, operator+= is expected to modify its left operand (d), but you are not doing that. Instead, you are creating a new object (p), initializing it with the value of d + n, and returning it.
When I write ``` Date a { <someCtor> }; Date b { a + 1 }; ``` then I do not expect a to be modified by a + 1. But in the above version, it is, right? So maybe, in operator+, use copy construction first, i.e. return Date{lhs} += rhs;
|
4

The main problem is that your += is creating a new Date object and returning it. That is the wrong semantics, plus you do not assign that return value to anything. A += operator should act on the instance it is applies to and return it by reference:

inline Date& operator+=(Date& d, int n) { return d = d + n; }

Usually, this would be implemented as a member function, with + implemented in terms of +=:

class Date { public: Date& operator+=(int n) { // perform whatever operation is required using // the state of the instance. return *this; } }; inline Date operator+(Date lhs, int rhs) { return lhs += rhs; // calls member += }

The cleanest way would be to provide a time duration class, and implement all the operators in terms of a Date and a TimeDuration:

struct TimeDuration { .... }; class Date { public: Date& operator+= (const TimeDuration& rhs) { .... } }; inline Date operator+(Date lhs, const TimeDuration& rhs) { return lhs += rhs; }
Improve this answer

4 Comments

What exactly would it mean to add two dates to each other?
@BenjaminLindley It would mean I haven't had any coffee yet. What is needed is a time difference type, but I think I will just delete this useless answer.
thanks! I would define it within the class instead of inline, but my assignment seems to require an inline code.
@PatrickJane technically, if you declare and define a method inside a class it is implicitly inline. Boncerning my discussion with Benjamin, the idea is that you define a simple "time duration" type, what you can use to add to dates. It would also express the difference between two dates.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.