friend function of a templated class needs access to member type

Question

I need to define a friend function for the templated class. The function has return type that is a member type of the class. Now, I can not declare it beforehand, since the the return type is not known at the time. Something like this

template<class T> class A; 

//This doesn't work: error: need ‘typename’ before...  
template<class T> A<T>::member_type fcn(A<T>::member_type);

//This doesn't work: error: template declaration of ‘typename...
template<class T> typename A<T>::member_type fcn(A<T>::member_type);

template<class T>
class A{
public:
  typedef int member_type;
  friend member_type fcn<T>(member_type);
};

How do I do this?

In your example, I would strongly recommend to declare `fcn()` as public static function of class `A` — Alex Cohn, Oct 18 '12 at 20:54

score 1 · Accepted Answer · answered Oct 18 '12 at 20:50

1

I managed to compile that code on g++ using :

template<class T> typename A<T>::member_type fcn(typename A<T>::member_type);

(Thus a second 'typename' was required)

answered Oct 18 '12 at 20:50

gogoprog

613
4
7

score 1 · Answer 2 · answered Oct 18 '12 at 20:51

1

You need to say typename also in the argument:

template <class T>
typename A<T>::member_type fcn(typename A<T>::member_type);
//                             ^^^^^^^^

Otherwise there's no problem with your code, as long as all the template definitions appear before the function template is first instantiated.

answered Oct 18 '12 at 20:51

Kerrek SB

464,522
92
875
1,084

Thanks, but gogoprog was there first. – user1672572 Oct 18 '12 at 21:25

score 1 · Answer 3 · answered Oct 18 '12 at 20:52

It seems that in your particular example nothing in fcn function actually depends on class A. It doesn't even need to access any of the A's methods/fields, neither public nor protected/private. So it doesn't make sense. It would have made some sense otherwise, but at any rate it seems like it is worth re-thinking your problem and come up with a cleaner solution that does not need a hack like that. If, after a deep thought, you still believe you need it, you can do something like this:

#include <cstdio>

template<typename T> typename T::member_type fcn(const T & v) {
    return v.value_;
}

template<class T>
class A {
  public:
    typedef T member_type;

    friend member_type fcn< A<T> >(const A<T> &);

    A() : value_(1986) {}

  private:
    T value_;
};

int main()
{
    A<int> a;
    printf("The value is: %d\n", fcn(a));
}

Notable thing in the above example is that you need to de-couple a cross dependency and make your free-function not depend on a declaration of class A. If you still feel like you need that coupling, the following code works, too:

#include <cstdio>

template <typename T>
class A;

template <typename T> typename A<T>::member_type fcn(const A<T> & v) {
    return v.value_;
}

template <typename T>
class A {
  public:
    typedef int member_type;

    friend member_type fcn<T>(const A<T> &);

    A() : value_(1986) {}

  private:
    member_type value_;
};

int main()
{
    A<void> a;
    printf("The value is: %d\n", fcn(a));
}

Hope it helps. Good Luck!

'fcn' does access 'A'`s fields. 'member_type' is in fact something like 'set'. Your example compiles, but once 'member_type' is in the parameters of 'fcn', I get 'error: template declaration of ‘typename...'. For example — user1672572, Oct 18 '12 at 21:12
@user1672572: Well, I believe your are very close to do whatever you want, and it should work as long as you don't forget typing `typename`. Otherwise... post a specific problem that you are having... or else it's really hard to guess to help you. — , Oct 18 '12 at 21:14
For example you code modified so that fcn takes an arg of 'member_type' as above, does not compile. — user1672572, Oct 18 '12 at 21:19

score 1 · Answer 4 · answered Oct 18 '12 at 20:59

This may by now be redundant with someone else's answer, but here's a complete, testable solution. The final function definition is a template specialization of fcn, which will produce a compiler error indicating that A<double>::x is not accessible from fcn<int>, but A<int>::x is accessible.

template<class T> class A; 

template <typename U>
typename A<U>::member_type fcn(typename A<U>::member_type);

template<class T>
class A {
    int x;
  public:
    typedef int member_type;
    friend typename A<T>::member_type fcn<T>(typename A<T>::member_type);
};

template<>
int fcn<int>(int x)
{
    A<int> i;
    A<double> d;
    i.x = 0;  // permitted
    d.x = 0;  // forbidden
    return 0;
}

friend function of a templated class needs access to member type

4 Answers4