How to make template function friend of template class

Question

I have a template class with private constructor and destructor:

template <typename T>
class Client
{
    private:
        Client(...) {}
        ~Client()   {}

        template <typename U>
        friend class Client<T>& initialize(...);
};


template <typename T>
Client<T> initialize(...) 
{
      Client<T> client = new Client<T>(...);
}

I'm not sure of the correct syntax for the friend. Can anybody help?

You should read this [answer](http://stackoverflow.com/questions/4660123/overloading-friend-operator-for-template-class/4661372#4661372) to a related question. It is about overloading `operator<<`, but all of the reasoning applies here. — David Rodríguez - dribeas, Jul 25 '11 at 16:40

In silico · Accepted Answer · 2011-07-25T16:21:14.383

Ignoring the ellipses (which I assume mean "a bunch of parameters that aren't relevant to the question"), this should work:

template <typename T>
class Client
{
private:
    Client() {} // Note private constructor
public:
    ~Client() {} // Note public destructor

    // Note friend template function syntax
    template<typename U>
    friend Client<U> initialize();
};


template<typename T>
Client<T> initialize() 
{
      /* ... */
}

Notice that the friend declaration is essentially the same as the function declaration but with the friend keyword prefixed before the return type.

Also, the destructor is public so that users of initialize() will be able to destruct the returned instance of Client<>. The constructor is still private so only initialize() can create instances of it.

The above code should allow this to work:

int main()
{
    Client<int> client = initialize<int>();
}

score 1 · Answer 2 · answered Jul 25 '11 at 16:14

1

template <typename U> friend Client<U> initialize(.....);

answered Jul 25 '11 at 16:14

Alok Save

202,538
53
430
533

score 1 · Answer 3 · edited May 23 '17 at 12:19

It depends on what exactly you are trying to achieve. You may want to befriend a single instantiation of the template, or you might want to befriend all instantiations. Finally you might not really want to befriend a template, but just a non-templated function that is automatically generated by the compiler upon instantiation of your class template...

Befriending the whole template:

template <typename T>
class MyClass {
   template <typename U>
   friend MyClass<U> f();
};

Befriending a concrete instantiation (i.e. allowing f<int> access to MyClass<int> but not to MyClass<double>):

// Forward declarations
template <typename T>
class MyClass;
template <typename T>
MyClass<T> f();

// Definition of class template
template <typename T>
class MyClass {
   friend MyClass<T> f<T>();
};

// Definition of friend function
template <typename T>
MyClass<T> f() { ... }

Automatic instantiation of a befriended non-template function:

template <typename T>
class MyClass {
    friend MyClass<T> f() { ... } // define inline
};

I would recommend that you use the latter, unless the function is parametrized with other template parameters than the T for MyClass<T>.

Recommend reading: overloading friend operator<< for template class

score 0 · Answer 4 · answered Jul 25 '11 at 16:18

You should probably make your destructor public. If you need to keep it private you need to declare another friend function to delete the Client objects that you've created.

template <typename T>
class Client
{
    private:
        Client() {}
        ~Client() {}

        template <typename U>
        friend Client<U> *initialize();

        template <typename U>
        friend void destroy( Client<U> * );
};


template <typename T>
Client<T> *initialize() 
{
  return new Client<T>();
}

template <typename T>
void destroy( Client<T> *client )
{
  delete client;
}

int main()
{
  auto client = initialize<int>();

  destroy( client );

  return 0;
}

How to make template function friend of template class

4 Answers4

Linked