如何使模板函数成为模板类的友元

Question

我有一个带有私有构造函数和析构函数的模板类：

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>(...);
}

我不确定朋友的语法是否正确。有人可以帮忙吗？

Answer 1

忽略省略号（我认为它的意思是“一堆与问题无关的参数”），这应该有效：

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() 
{
      /* ... */
}

请注意，朋友声明本质上与函数声明相同，但带有 friend 关键字在返回类型之前添加前缀。

此外，析构函数是公共的，因此 initialize() 的用户将能够析构 Client 返回的实例。构造函数仍然是私有的，因此只有 initialize() 可以创建它的实例。

上面的代码应该允许这个工作：

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

Answer 2

这取决于您到底想要实现什么目标。您可能希望与模板的单个实例成为朋友，或者您可能希望与所有实例成为朋友。最后，您可能并不是真的想与模板交朋友，而只是在实例化类模板时由编译器自动生成的非模板化函数...

与整个模板交朋友：

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

与具体实例交朋友（即允许 f< ;int> 访问 MyClass 但不能访问 MyClass)：

// 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() { ... }

自动实例化友好的非模板function：

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

我建议您使用后者，除非该函数使用除 MyClass 的 T 之外的其他模板参数进行参数化。

推荐阅读：重载好友运算符<<对于模板类

Answer 3

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

Answer 4

您可能应该将析构函数设为公开。如果您需要将其保持私有，则需要声明另一个friend函数来删除您创建的Client对象。

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;
}