Question

我正在处理一段看起来像这样的代码：

template<typename T>
class A {
    // makeA should become a friend
    A() {}
};

template<typename T, typename U>
A<T> makeA(const U & u) {
    (void) u;
    return A<T>();
}

int main() {
    makeA<double>(3);
    return 0;
}

但我不能让makeA成为A的朋友。这可能吗？什么是正确的语法？

Answer 1

您可以将其设为friend：

template<typename T>
class A
{

   template<typename TT, typename U>
   friend A<TT> makeA(const U & u) ;

};

您甚至可以在类中定义friend函数。

Answer 2

虽然解决方案

template <typename T>
class A
{

   template<typename TT, typename U>
   friend A<TT> makeA(const U & u) ;

};

有效，它会产生副作用，makeA<int, int>不仅是A<int>的朋友，还是A<double>，A<char>的朋友等。在其他工作中，makeA<TT, U>是每个A<T>的朋友。 A<T>授予的友谊过于宽泛。

您可以使用其他设计来限制它。

template <typename T> class AMaker;

template <typename T>
class A
{
   A() {}

   friend class AMaker<T>;
};

template<typename T> class AMaker
{
   public:
      template <typename U>
         static A<T> make(const U & u)
         {
            (void) u;
            return A<T>();
         }
};

int main()
{
   A<double> x = AMaker<double>::make(3);
   return 0;
}

此处，A<T>授予的友谊仅限于AMaker<T>。 AMaker<int>是A<int>的朋友，但不是A<double>的朋友。

Answer 3

我已对您的计划进行了一些更改模板

class A {
    // makeA should become a friend

    A() {} 
    public:
    template<typename S,typename U>
    friend A<S> makeA(const U & u); //this is correct way to makeA friend of A
};

template<typename T, typename U>
A<T> makeA(const U & u) {
    (void) u;
    return A<T>();
}

int main() {
  makeA<double>(3);
    return 0;
}

现在它可以正常工作，你可以在这里看到 http://ideone.com/1F1l3o

Answer 4

以下是不使用friend的解决方案：

template<class T>
class A {
    A() {}
public:
    template<class U> static A make(U && u) {
        return A();
    }
};

template<class T, class U>
A<T> makeA(U && u) {
    return A<T>::template make<U>(std::forward<U>(u));
}

模板工厂功能与其他args：友谊问题

4 个答案: