Friend operators for template class - c++

Question

I have a template class, to which I declared 2 operator+ methods. Their declaration is:
1) const MyClass<T> operator+ (int num) const;
and
2) friend const MyClass<T> operator+ <>(int num, const MyClass<T>& other);
Following this FAQ, the .hpp file looks something like this:
//forward declaration of the class.
template<class T>
class MyClass;
//forward declaration of the operator+
template<class T>
const MyClass<T> operator+ (int num, const MyClass<T>& other);
template<class T>
class MyClass {
public:
...
const MyClass<T> operator+ (int num) const;
friend const MyClass<T> operator+ <>(int num, const MyClass<T>& other);
...
};
(And later I have the definitions of those methods).
Note that the 2 operator+ methods are used in different situations:
The first in
MyClass mc;
mc+5;
And the second in
MyClass mc;
5+mc;
But for some reason, when I compile it in g++ (version 4.8.2, if that matters), I get the error:
declaration of ‘operator+’ as non-function
friend const MyClass<T> operator+ <>(int num, const MyClass<T>& other);
Note that the error refers to the friend operator+ method
But, if I remove the declaration of the first operator+ method (i.e. leaving only the friend one), then everything compiles just fine!
What is going on?

Answer 1

Not sure why, but switching the order makes it compile (will try to find an explaination):
//forward declaration of the class.
template<class T>
class MyClass;
//forward declaration of the operator+
template<class T>
const MyClass<T> operator+(int num, const MyClass<T>& other);
template<class T>
class MyClass {
public:
friend const MyClass<T> operator+<>(int num, const MyClass<T>& other);
const MyClass<T> operator+ (int num) const;
};
EDIT
Thanks to Maksim for pointing out that my doubts were true. What happens is that the names of both operators clash and thus the error. Normally the second operator would have the class name in it's name, but since in the class declaration you are inside class scope the names clash. If the non class member operator would be in a different namespace, e.g:
//forward declaration of the class.
template<class T>
class MyClass;
//forward declaration of the operator+
namespace Foo
{
template<class T>
const MyClass<T> operator+(int num, const MyClass<T>& other);
}
template<class T>
class MyClass {
public:
const MyClass<T> operator+ (int num) const;
friend const MyClass<T> Foo::operator+<>(int num, const MyClass<T>& other);
};
using namespace Foo;
int main()
{
MyClass<int> a;
5 + a;
}
it would be fine since the names would be distinct. Also if you would use them as friends on another object it would also be fine:
//forward declaration of the class.
template<class T>
class MyClass;
//forward declaration of the operator+
template<class T>
const MyClass<T> operator+(int num, const MyClass<T>& other);
template<class T>
class MyClass {
public:
const MyClass<T> operator+ (int num) const;
};
template <typename T>
class Foo
{
friend const MyClass<T> operator+<>(int num, const MyClass<T>& other);
friend const MyClass<T> MyClass<T>::operator+(int num);
};
int main()
{
MyClass<int> a;
5 + a;
}
I hope this explains these examples explain the cause.

Answer 2

For the most part, this is what you actually want:
template<class T>
class MyClass {
public:
MyClass operator+ (int num) const;
friend MyClass operator+(int num, const MyClass& other) {
return other+num;
}
};
I made a number of changes, all on purpose.
I removed the forward declaration of MyClass<T> and operator+, because neither are needed.
I made the non-member operator+ an inline friend, and no longer a template. This is what I call a Koenig operator: it can only be accessed via ADL (argument dependent lookup) on MyClass. It is not a template: however one independent non-template function is created for each template class.
As this function is almost certainly just going to mindlessly forward its arguments to the member operator+, I did it inline right there.
Finally, I removed const from the return type. const in return types does little except block some move optimizations.
The end result is code that is shorter, simpler and easier to work with.
I often go a step further when I want an industrial quality solution:
template<class T>
class MyClass {
public:
MyClass& operator+=(int num); // do actual work here
template<class Self>
friend MyClass operator+(int num, Self&& self) {
auto tmp = std::forward<Self>(self); // perfect forwarding
tmp += num; // delegate to +=
return tmp; // elide return value
}
template<class Self>
friend MyClass operator+(Self&& self, int num) {
return num + std::forward<Self>(self); // DRY principle
}
};
where I forward everything through to member +=. The above version also enables perfect forwarding of MyClass into +. While the operator looks overly greedy (I mean, it doesn't seem to restrict Self to be of type MyClass at all!), because it can only be found via ADL on MyClass<T>, self must be a reference to an instance of MyClass!
clang interestingly requires a template<class Self, std::enable_if_t<std::is_class<std::decay_t<Self>>{}>* = nullptr> for the operator+s due to it treating some restrictions on operator+ as hard errors, instead of SFINAE errors.
This strategy, basing other operators off += style operators, and using Koenig operators for + style operators that just forward to +=, works well in a wide variety of situations.
You can even use inheritance to strip out the boilerplate to convert += into +. This doesn't even require CRTP.
struct plus_impl {
template<class Self,
std::enable_if_t<std::is_class<std::decay_t<Self>>{}>* = nullptr
>
friend std::decay_t<Self> operator+(int num, Self&& self) {
auto tmp = std::forward<Self>(self); // perfect forward a copy
tmp += num; // delegate to +=
return tmp; // elide return value
}
template<class Self,
std::enable_if_t<std::is_class<std::decay_t<Self>>{}>* = nullptr
>
friend std::decay_t<Self> operator+(Self&& self, int num) {
return num + std::forward<Self>(self); // DRY principle
}
};
template<class T>
class MyClass : public plus_impl {
public:
MyClass& operator+=(int num){
std::cout << "+=" << num << "\n";
return *this;
}
};
live example.
We use the magic of ADL here. Inheriting from plus_impl means that MyClass<T> + int finds the operator+ in plus_impl. As operator+ is a template operator, it actually gets the MyClass<T> as a MyClass<T>, not as a plus_impl. The implementation of operator+ then uses MyClass<T>'s += to do the work.
I believe this technique is similar to how boost::operators work, except it uses CRTP (I remember some discussion about them using it because some older compilers didn't do the right thing without it?)
Another fun thing about this technique is that subclasses of MyClass<T> magically get + support.

Answer 3

I think this should look like this:
//forward declaration of the class.
template<class T>
class MyClass;
//forward declaration of the operator+
template<class T>
MyClass<T> operator+ (int num, const MyClass<T>& other);
template<class T>
class MyClass {
public:
MyClass<T> operator+ (int num) const;
template<typename P> friend MyClass<P> operator+ (int num, const MyClass<P>& other);
};
Returning const MyClass<T> make no sence because const is discarded anyway.