专业模板类的朋友（C ++）

Question

#include <iostream>
using namespace std;
template <typename T>
class test
{
    T y;

public:
    test(T k) : y(k) {}
    friend int a(T& x);
};

template <typename T>
int a(T& x)
{
    cout << x.y;
    return 9;
}

template <>
class test<int>
{
    int y;
public:
    test(int k) : y(k) {}
    friend int a(int& x);
};

template <>
int a<int>(int& x)
{
    cout << "4";
    return 0;
}

int main(int argc, char* argv[])
{
    test<int> z(3);
    a(z);

    return 0;
}

I want to make a friend class of test class (in a real case, it was a operator<< of ofstream). But I have no idea how to define template friend function of specialized class.

Besides, the code above shows this compile error message;

error C2248: 'test::y' : cannot access private member declared in class 'test'

Question added;

Aaron McDaid works fine for me, but I was trying to overload operator<< of ofstream class.

friend ofstream& operator<< <test<int>> (ofstream& os, const test<int>& t);

I added code above to test class and

template<>
ofstream& operator<< <test<int> > (ofstream& os, const test<int>& t)
{
    os << t.y;
    return os;
}

used code above. But it looks like I cannot use os << ty (which is int ) I don't understand why this happens. The error message is

error C2027: use of undefined type 'std::basic_ofstream<_Elem,_Traits>'

Answer 1

This friend isn't a template, but an ordinary function:

friend int a(T& x); 

To have a template that is also a friend, try:

template<class U>
friend int a(U& x); 

---

After the discussions in the comments, perhaps I should show that I intended these declarations for the test class and its specialization:

template <typename T>
class test
{
    T y;

public:
    test(T k) : y(k) {}

    template<class U>
    friend int a(U& x); 
};

template <>
class test<int>
{
    int y;
public:
    test(int k) : y(k) {}

    template<class U>
    friend int a(U& x); 
};

A slight disadvantage is that this makes all the a functions friends of all the test classes, but that is often not a big problem.

Answer 2

( Update : Here's a fully tested version on http://ideone.com/3KGU4 . For the Additional question , see http://ideone.com/w0dLo )

There is a difference between ordinary overloaded functions and template functions. For example, without any reference to templates a developer can declare:

void f(int x);
void f(char *x);

Alternatively, a developer could use templates,

template <class T> void f(T x);

A major difference between them is that with ordinary functions, you must decide on a fixed set of allowed parameters in advance, and you must provide an implementation for each one. With templates, you can be more flexible.

Later in your program, it is clear that you want a to be a template function, not simply an (overloaded) ordinary function. But when the compiler first sees mention of a (around line 10), it looks like it is declaring an ordinary function. To resolve this, you must take two steps. You must declare as soon as possible that a is a template function, so your first line should be:

template <typename T> int a(T& x);

Then you must declare the relevant friendship. If T is int , then a takes a parameter of test<int>& , not int& . Therefore the two friend lines should be replaced with:

friend int a<test<T> >( test<T> & x); // around line 10
friend int a<test<int> >( test<int> & x); // around line 27

and the specialization of a should be:

template <>
int a< test<int> >(test<int>& ) // around line 30

The Additional Question

Use ostream instead of ofstream (or else include #include <fstream> if you will output only to files and not to cout ). In my answer, operator << is not a template, but is a normal overloaded function. I'm not sure it's possible to have operator<< as a template. Also, I defined the operator at the place where it is declared and declared as a friend. To be honest, I think there are other, maybe better, ways but this worked for me.

Answer 3

Try this, and it works

#include <iostream>
using namespace std;

template <typename T>
class test;

template <typename T>
int a( test<T>& x);

template <typename T>
class test
{
    T y;

public:
    test(T k) : y(k) {}
    friend int a<T>( test<T>& x);
};

template <typename T>
int a( test<T>& x)
{
    cout << x.y;
    return 9;
}

template <>
class test<int>
{
    int y;
public:
    test(int k) : y(k) {}

    friend int a<int>( test<int> & x);
};

template <>
int a< int >( test<int> & x)
{
    cout << "4";
    return 0;
}

int main(int argc, char* argv[])
{
    test<int> z(3);
    a(z);

    return 0;
}

The problem is, template function a takes a parameter of test template class. If you want both of them to have the same template argument then , IMO you need to explicitly state that

template <typename T>
    int a( test<T>& x);

Also specialization of function a for int ( template<> int a(int& x) ) isn't useful here. You need to have

template <> int a<int>( test<int> & x)