C++ How to specify all friends of a templated class with a default argument?

Question

To define a friend of a templated class with a default argument, do you need to specify all friends as in the code below (which works)?

// Different class implementations
enum ClassImplType { CIT_CHECK, CIT_FAST, CIT_GPU, CIT_SSE, CIT_NOF_TYPES } ;

// Graph class has default template argument CIT_CHECK
template <typename T, ClassImplType impl_type = CIT_CHECK>
class graph {
  //...
};

// Vertex class
template <typename T>
class vertex {
  //...
  friend class graph<T, CIT_CHECK>;
  friend class graph<T, CIT_FAST>;
  friend class graph<T, CIT_GPU>;
  friend class graph<T, CIT_SSE>;
};

I can imagine that there is a shorter way to denote that the friend is defined for all possible ClassImplType enum values. Something like friend class graph<T, ClassImplType>, but the latter doesn't work of course.

Apologies if the terminology I use is incorrect.

Answer 1

I can imagine that there is a shorter way to denote that the friend is defined for all possible ClassImplType enum values.

Sadly, there really isn't. You might try with

template<ClassImplType I> friend class graph<T, I>;

but the standard simply forbids one to befriend partial specializations:

§14.5.4 [temp.friend] p8

Friend declarations shall not declare partial specializations. [ Example:

template<class T> class A { };
class X {
  template<class T> friend class A<T*>; // error
};

—end example ]

You can only either befriend them all:

template<class U, ClassImplType I>
friend class graph;

Or a specific one:

friend class graph<T /*, optional-second-arg*/>;

I can't see how befriending all possible specializations might cause a problem here, to be honest, but let's assume it does. One workaround I know would be using the passkey pattern, though we'll use a slightly cut-down version (we can't use the allow mechanism here, since it doesn't work well for allowing access to all specializations of a template):

template<class T>
class passkey{    
  passkey(){}
  friend T;

  // optional
  //passkey(passkey const&) = delete;
  //passkey(passkey&&) = delete;
};

// Different class implementations
enum ClassImplType { CIT_CHECK, CIT_FAST, CIT_GPU, CIT_SSE, CIT_NOF_TYPES } ;

template<class> struct vertex;

// Graph class has default template argument CIT_CHECK
template <typename T, ClassImplType impl_type = CIT_CHECK>
class graph {
public:
  void call_f(vertex<T>& v){ v.f(passkey<graph>()); }
  //...
};

// Vertex class
template <typename T>
class vertex {
  //...
public:
  template<ClassImplType I>
  void f(passkey<graph<T,I>>){}
};

Live example with tests.

You'll note that you need to make all functionality that graph needs to access public, but that's not a problem thanks to the passkeys, which can only ever be created by the specified graph specializations.

You can also go farther and create a proxy class which can be used to access the vertex functionality (only graph changes):

// Graph class has default template argument CIT_CHECK
template <typename T, ClassImplType impl_type = CIT_CHECK>
class graph{
  typedef passkey<graph> key;
  // proxy for succinct multiple operations
  struct vertex_access{
    vertex_access(vertex<T>& v, key k)
      : _v(v), _key(k){}

    void f(){ _v.f(_key); }

  private:
    vertex<T>& _v;
    key _key;
  };

public:
  void call_f(vertex<T>& v){
    vertex_access va(v, key());
    va.f(); va.f(); va.f();
    // or
    v.f(key());
  }
  //...
};

Live example.

Answer 2

You can template the friend statement:

template<typename U, ClassImplType  V>
friend class graph_foo;

I'm trying to figure out how to keep the T - I'll update if I find out.

Answer 3

I thought of the following way to 'fix it' by using recursive inheritance.

Inline comments explain what's happening:

#include <type_traits>
#include <string>
#include <iostream>
#include <typeinfo>

// Different class implementations
enum ClassImplType { CIT_CHECK, CIT_FAST, CIT_GPU, CIT_SSE, CIT_NOF_TYPES };

template <typename T, ClassImplType impl_type = CIT_CHECK>
class graph;

// Vertex class
namespace impl
{
    template <typename, ClassImplType, typename enabler = void> struct vertex_impl;

    ///////////////////////////////////////////////////////////////
    // actual implementation (stop condition of recursion)
    static const ClassImplType CIT_ENDMARKER = (ClassImplType) -1;

    template <typename T> struct vertex_impl<T, CIT_ENDMARKER> 
    {
        protected: // make it protected rather than private
            int secret() const { return 42; }
    };

    ///////////////////////////////////////////////////////////////
    // recursion, just to mark friends
    template <typename T, ClassImplType impl_type>
        struct vertex_impl<T, impl_type, typename std::enable_if<CIT_ENDMARKER != impl_type>::type>
            : public vertex_impl<T, ClassImplType(impl_type - 1)>
        {
             friend class ::graph<T, impl_type>;
        };
}

///////////////////////////////////////////////////////////////
// Public typedef
#if 1
    template <typename T> struct vertex : impl::vertex_impl<T, CIT_NOF_TYPES> { };
#else // or c++11
    template <typename T> using vertex = impl::vertex_impl<T, CIT_NOF_TYPES>;
#endif

template <typename T, ClassImplType impl_type>
class graph
{
    public:
        static void TestFriendOf(const vertex<T>& byref)
        {
            std::cout << byref.secret() << std::endl;
        }
};

int main(int argc, const char *argv[])
{
    vertex<int> t;

    graph<int, CIT_CHECK>     :: TestFriendOf(t);
    graph<int, CIT_FAST>      :: TestFriendOf(t);
    graph<int, CIT_GPU>       :: TestFriendOf(t);
    graph<int, CIT_SSE>       :: TestFriendOf(t);
    graph<int, CIT_NOF_TYPES> :: TestFriendOf(t);
}

This works on gcc and clang.

See it live on http://liveworkspace.org/code/f03c0e25a566a4ca44500f4aaecdd354

PS. This doesn't exactly solve any verbosity issues at first sight, but you could make the solution more generic, and inherit from a different 'base-case' instead of the hard-coded one, in which case the boileplate could potentially be compensated for (in case you have many classes that need to befriend families of graph types)

Answer 4

Class cannot become friend of partial specialization according to this "non-bug" explanation: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=5094

 What clenches it is that 14.5.3, p9
 explicitly prohibits friend declarations of partial specializations:

   -9- Friend declarations shall not declare partial specializations.
       [Example:
           template<class T> class A { };
           class X {
               template<class T> friend class A<T*>; // error
           };
       容nd example]

But I come to the solution, which does not look perfect, neither it is easy to use. The idea is to create intermediate friend inner class, just to forward "friendship" to outer class. The disadvantage (or advantage?) is that one has to wrap all function/member variables which shall be available to outer friend:

// Different class implementations
enum ClassImplType { CIT_CHECK, CIT_FAST, CIT_GPU, CIT_SSE, CIT_NOF_TYPES } ;

template <typename T>
class vertex;

// Graph class has default template argument CIT_CHECK
template <typename T, ClassImplType impl_type = CIT_CHECK>
class graph {
    typedef typename vertex<T>::template graph_friend<impl_type> graph_friend;
public:
  graph(vertex<T>& a) { graph_friend::foo(a); } // here call private method    
  //...
};

// Vertex class
template <typename T>
class vertex {
  //...
  int foo() {}
public:
  template <ClassImplType impl_type>
  class graph_friend {
     static int foo(vertex& v) { return v.foo(); }
     friend class graph<T,impl_type>;
  };

};
int main() {
    vertex<int> a;
    graph<int,CIT_SSE> b(a);

}