template friend operator functions

I have a question about template friend functions. Is the declaration in the Stack class correct? It compiles in 2 different compilers, so I guess its correct but what does the '<>' operator mean in this context? its not a template specialization but what is it?

Code:

template <typename T, unsigned int N> 
class Stack 
{
public: 
  friend ostream &operator<< <>(ostream &os, const Stack<T, N> &s); 

private: 
  T m_stack[N];
};

template<typename T, unsigned int N> 
ostream &operator<<(ostream &os, const Stack<T, N> &s) 
{
  if (!s.empty()) 
  {
    T *cur = s.m_cur;
    while (cur != s.m_stack) 
    {
      os << *--cur << ' '; 
    }
  }
  return os; 
}

Originally Posted by KIBO

I have a question about template friend functions. Is the declaration in the Stack class correct? It compiles in 2 different compilers, so I guess its correct but what does the '<>' operator mean in this context? its not a template specialization but what is it?

I had not actually seen that before. But after some experimentation, it seems like it's equivalent to:

Code:

template <typename T2, unsigned int N2>
friend ostream &operator<<(ostream &os, const Stack<T2, N2> &s);

Where T2=T, N2=N.

I think this is relevant: Why do I get linker errors when I use template friends?

Originally Posted by anon

I think this is relevant: Why do I get linker errors when I use template friends?

I don't get any linker error -- that code compiles (with a few obvious tweaks).

It doesn't compile with GCC (4.4.1):

8 Untitled1.cpp template-id 'operator<< <>' for 'std::ostream& operator<<(std::ostream&, const Stack<int, 2u>&)' does not match any template declaration

When <> is taken out:

8 Untitled1.cpp [Warning] friend declaration 'std::ostream& operator<<(std::ostream&, const Stack<T, N>&)' declares a non-template function
(if this is not what you intended, make sure the function template has already been declared and add <> after the function name here)

and a linker error.

Of course, the compiler may be wrong.

Compiles with GCC 4.5.0:

Code:

#include <iostream>

using namespace std;

template <typename T, unsigned int N>
class Stack;

template<typename T, unsigned int N>
ostream &operator<<(ostream &os, const Stack<T, N> &s)
{
  if (!s.empty())
  {
    T *cur = s.m_cur;
    while (cur != s.m_stack)
    {
      os << *--cur << ' ';
    }
  }
  return os;
}

template <typename T, unsigned int N>
class Stack
{
public:
  friend ostream &operator<< <>(ostream &os, const Stack<T, N> &s);

private:
  T m_stack[N];
};

int main()
{
    Stack<int, 10> stack;
}

When you take out the <> you get these errors:

/home/daemn/Temporary/asdasdasda/main4.cpp|26|warning: friend declaration ‘std:stream& operator<<(std:stream&, const Stack<T, N>&)’ declares a non-template function|
/home/daemn/Temporary/asdasdasda/main4.cpp|26|note: (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) |
/home/daemn/Temporary/asdasdasda/main4.cpp||In function ‘int main()’:|
/home/daemn/Temporary/asdasdasda/main4.cpp|34|warning: unused variable ‘stack’|
||=== Build finished: 1 errors, 2 warnings ===|

So it's basically short-hand?

I think it is the same as here:

Code:

#include <iostream>

template <class T>
void foo(const T& )
{
    std::cout << "T\n";
}

template <>
void foo<>(const int& ) //or void foo<int>(const int&)
{
    std::cout << "<int>\n";
}

void foo(int )
{
    std::cout << "int\n";
}

int main()
{
    foo(3);
    foo<>(3); //indicates desire to use a template function
}

Essentially repeating the type appears to be optional.

Originally Posted by brewbuck

I had not actually seen that before. But after some experimentation, it seems like it's equivalent to:

Code:

template <typename T2, unsigned int N2>
friend ostream &operator<<(ostream &os, const Stack<T2, N2> &s);

Where T2=T, N2=N.

This is true, but this form does not compile on somewhat older compilers like visualC++ 2005 and BCbuilder6.

The operator<< <>() together with forward declares seems to work on more compilers while they are both standard C++.
I was more wondering about how I should read the operator<< <>() syntax.

I had not actually seen that before. But after some experimentation, it seems like it's equivalent to:

Code:

template <typename T2, unsigned int N2>
friend ostream &operator<<(ostream &os, const Stack<T2, N2> &s);

I may be mistaken, but this declares operator<< a friend for any Stack instantiation, whereas other forms limit the friendship only to one particular instantiation (not that it should matter at all).

However, one might need to be careful, for example, to avoid declaring A<int> a friend of B<float>, where the intent was to allow friendship only for A<float>.

Ah, template friends, the last bastion of cross-compiler syntax confusion.

Code:

template <typename T>
void fn4(const T& t);

template <typename T>
struct Ex
{
  // Any instantiation of Ex is friend to any instantiation of fn1.
  // This also declares the free function template fn1 in Ex's enclosing scope,
  // but the declaration is not visible to qualified lookup.
  template <typename U>
  friend void fn1(const U& u);

  // Any given instantiation Ex<C> is friend to the non-template function fn2(const C&).
  // You'd have to declare and define a separate function for every instantiation, though.
  // You could define this function inline right here to make this work.
  // This also declares the free function fn2 in Ex's enclosing scope, but the declaration is
  // not visible to qualified lookup.
  friend void fn2(const T& t);

  // Error. This tries to friend a specialization of the function template fn3, but there is no
  // such function template declared. However, due to the way some compilers (e.g. VC++)
  // parse templates, this might actually work if the template fn3 is declared before Ex is
  // instantiated. GCC, however, will refuse to compile this.
  friend void fn3<>(const T& t);

  // Any given instantiation Ex<C> is friend to the specialization fn4<C> of the function
  // template declared at the top of this code.
  friend void fn4<>(const T& t);
};

Now substitute "operator <<" for "fnx" and you've got the original code in its variants. Operator names are just normal function names, but they tend to confuse the issue.

Originally Posted by CornedBee

Ah, template friends, the last bastion of cross-compiler syntax confusion.

Code:

template <typename T>
void fn4(const T& t);

template <typename T>
struct Ex
{
  // Any instantiation of Ex is friend to any instantiation of fn1.
  // This also declares the free function template fn1 in Ex's enclosing scope,
  // but the declaration is not visible to qualified lookup.
  template <typename U>
  friend void fn1(const U& u);

  // Any given instantiation Ex<C> is friend to the non-template function fn2(const C&).
  // You'd have to declare and define a separate function for every instantiation, though.
  // You could define this function inline right here to make this work.
  // This also declares the free function fn2 in Ex's enclosing scope, but the declaration is
  // not visible to qualified lookup.
  friend void fn2(const T& t);

  // Error. This tries to friend a specialization of the function template fn3, but there is no
  // such function template declared. However, due to the way some compilers (e.g. VC++)
  // parse templates, this might actually work if the template fn3 is declared before Ex is
  // instantiated. GCC, however, will refuse to compile this.
  friend void fn3<>(const T& t);

  // Any given instantiation Ex<C> is friend to the specialization fn4<C> of the function
  // template declared at the top of this code.
  friend void fn4<>(const T& t);
};

Now substitute "operator <<" for "fnx" and you've got the original code in its variants. Operator names are just normal function names, but they tend to confuse the issue.

Maybe im blind but whats the difference between fn3 and fn4?

Originally Posted by KIBO

Maybe im blind but whats the difference between fn3 and fn4?

Notice that fn4 is declared at the top.

Originally Posted by laserlight

Notice that fn4 is declared at the top.

ah yeah thanks