Overloaded Operator Help

That is not a prototype.

 

The reason is usually that Microsoft C++ compilers are rubbish and don't implement the language properly. But in this case, you can either overload the unary operator+ (the one that is used for +x), then it must either be a class method or a non-class function with a class as parameter, or you can overload the binary operator+ (the one that is used for x+y), then it must be either a class method with one parameter, or a non-class function with two parameters, of which at least one is a class, and you did neither.

But I would bet you meant to write

Code:

DateType DateType::operator+ (int numDays) { ... }

or

Code:

DateType operator+ (const DateType& date, int numDays) { ... }

and a windows compiler won't compile your code either.

 

This!

I started realizing this in my 1st year of my second college.

 

Could also be that the warning levels are different. I don't know if what is shown was referring to the header file or supposed to be some kind of sketch of an implementation with an empty body. Given that you are allowed to have an implementation in the header file, if the posted code is indeed from the header file that might have generated the error (warning ?).

Presumably the date class maintains days since some kind of epoch date, so the implementation could be something like.

Code:

DateType &operator+(int numDays) {
	this->dayNumber += numDays;
        // calculate new date based on days since epoch
        return this;
}

Although it would make more sense to add two dates than adding days to a date, but if the prototype looks like this for the above implementation, it should not be a problem.

Code:

DateType &operator+(int numDays);

 

I don't think so. The OP says that the error goes away when the parameter is changed from "int" to "DateType". That is exactly what would happen for the definition of a unary operator+

Code:

DateType operator+ (DateType x) { return x; }
DateType operator- (DateType x) { throw ("unary minus does not make sense for class DateType"); }
DateType operator+ (DateType x, int days) { calculate and return x + number of days }

 

Yeah, and that suggests that the declaration has an argument that is of type "DateType". But the posted code is claimed to be from the header file, and the argument is int. That is the confusing part, does the types differ in the header and implementation? Who knows, what is posted is not a prototype and since you can include an implementation in the header file that could be it.

If the OP hasn't vanished forever, it would be helpful to update the exact declaration and implementation. ie post exactly what is in the .h and .cpp file, then there is no question about what it is that has been posted.

For what is worth, I have actually overloaded the minus operator for a date type in C++ once. Subtracting two dates would give you the amount of days between the dates.

 

Makes totally sense for the binary minus operator - just not for unary minus operator.

 

Microsoft C++ compilers used to be bad, nowadays they're very good. Microsoft is also focusing a lot of effort on that area; google for "Going Native 2012" which MS hosted.

Back to the original issue: What I think happened is that you have a class definition containing the operator+. When it's inside a class definition, it is assumed that the only argument to the operator is the right-hand-side:

Code:

class DateTime
{
    ...
    DateTime& operator+(int rhs);
};

This defines an operator which takes a DateTime object as lhs and an integer as rhs, to be used like this:

Code:

DateTime a, b;
...
a = b + 42;

which is actually a syntactic shortcut for

Code:

a = b.operator+(42);

Operators need not be class members though, and you are free to define freestanding functions too:

Code:

DateTime operator+(const DateTime& lhs, int rhs);

The operator+ and (operator-) are special in that they also exist as unary operators (in the case of the + that's rather academic, in the case of the minus this is so that you can write "-d" where d is a DateTime - whatever that means).

Now, in your .cpp file, you started implementing the operators. But instead of typing this:

Code:

DateTime& DateTime::operator+(int rhs)
{
    AdvanceDays(rhs);
    return *this;
}

(i.e., the implementation of the member), you wrote this:

Code:

DateTime operator+ (int rhs)
{
   ...
}

I.e., a freestanding unary operator taking a single int as argument and returning a DateTime. The compiler hasn't seen the prototype of this function yet, but that doesn't matter: You're allowed to define this new function. But you can't redefine operators which already exist for the builtin types (the int, in this case) so you can't change the meaning of "+42". This is where the error comes from. I'm surprised that you got the same error when you changed that int to DateTime (unless DateTime is not really a class but just a typedef for an int, or something like that).