27

I'm having some problems defining some operator overloads for template classes. Let's take this hypothetical class for example.

template <class T> class MyClass { // ... };

operator+=

// In MyClass.h MyClass<T>& operator+=(const MyClass<T>& classObj); // In MyClass.cpp template <class T> MyClass<T>& MyClass<T>::operator+=(const MyClass<T>& classObj) { // ... return *this; }

Results in this compiler error:

no match for 'operator+=' in 'classObj2 += classObj1'

operator<<

// In MyClass.h friend std::ostream& operator<<(std::ostream& out, const MyClass<T>& classObj); // In MyClass.cpp template <class T> std::ostream& operator<<(std::ostream& out, const MyClass<T>& classObj) { // ... return out; }

Results in this compiler warning:

friend declaration 'std::ostream& operator<<(std::ostream&, const MyClass<T>&)' declares a non-template function

What am I doing wrong here?

Improve this question
2
  • can you post some real code which fails to compile? Commented Oct 25, 2010 at 12:08
  • @Naveen: you can get a zipped version at box.net/shared/v23rj2f8e7 Commented Oct 25, 2010 at 12:12

5 Answers 5

Reset to default
26

You need to say the following (since you befriend a whole template instead of just a specialization of it, in which case you would just need to add a <> after the operator<<):

template<typename T> friend std::ostream& operator<<(std::ostream& out, const MyClass<T>& classObj);

Actually, there is no need to declare it as a friend unless it accesses private or protected members. Since you just get a warning, it appears your declaration of friendship is not a good idea. If you just want to declare a single specialization of it as a friend, you can do that like shown below, with a forward declaration of the template before your class, so that operator<< is regognized as a template.

// before class definition ... template <class T> class MyClass; // note that this "T" is unrelated to the T of MyClass ! template<typename T> std::ostream& operator<<(std::ostream& out, const MyClass<T>& classObj); // in class definition ... friend std::ostream& operator<< <>(std::ostream& out, const MyClass<T>& classObj);

Both the above and this way declare specializations of it as friends, but the first declares all specializations as friends, while the second only declares the specialization of operator<< as a friend whose T is equal to the T of the class granting friendship.

And in the other case, your declaration looks OK, but note that you cannot += a MyClass<T> to a MyClass<U> when T and U are different type with that declaration (unless you have an implicit conversion between those types). You can make your += a member template

// In MyClass.h template<typename U> MyClass<T>& operator+=(const MyClass<U>& classObj); // In MyClass.cpp template <class T> template<typename U> MyClass<T>& MyClass<T>::operator+=(const MyClass<U>& classObj) { // ... return *this; }
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

19 
// In MyClass.h MyClass<T>& operator+=(const MyClass<T>& classObj); // In MyClass.cpp template <class T> MyClass<T>& MyClass<T>::operator+=(const MyClass<T>& classObj) { // ... return *this; }

This is invalid for templates. The full source code of the operator must be in all translation units that it is used in. This typically means that the code is inline in the header.

Edit: Technically, according to the Standard, it is possible to export templates, however very few compilers support it. In addition, you CAN also do the above if the template is explicitly instantiated in MyClass.cpp for all types that are T- but in reality, that normally defies the point of a template.

More edit: I read through your code, and it needs some work, for example overloading operator[]. In addition, typically, I would make the dimensions part of the template parameters, allowing for the failure of + or += to be caught at compile-time, and allowing the type to be meaningfully stack allocated. Your exception class also needs to derive from std::exception. However, none of those involve compile-time errors, they're just not great code.

Improve this answer

Comments

11

This helped me with the exact same problem.

Solution:

  1. Forward declare the friend function before the definition of the class itself. For example:

     template<typename T> class MyClass; // pre-declare the template class itself template<typename T> std::ostream& operator<< (std::ostream& o, const MyClass <T>& x);

  2. Declare your friend function in your class with "<>" appended to the function name.

     friend std::ostream& operator<< <> (std::ostream& o, const Foo<T>& x);
Improve this answer

Comments

0

You must specify that the friend is a template function:

MyClass<T>& operator+=<>(const MyClass<T>& classObj);

See this C++ FAQ Lite answer for details.

Improve this answer

Comments

-3

This way works: 

class A { struct Wrap { A& a; Wrap(A& aa) aa(a) {} operator int() { return a.value; } operator std::string() { stringstream ss; ss << a.value; return ss.str(); } } Wrap operator*() { return Wrap(*this); } };
Improve this answer

1 Comment

Where are templates here?

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.