模板类的朋友功能需要访问会员类型

friend function of a templated class needs access to member type

本文关键字：访问 类型 功能 朋友      更新时间：2023-10-16

我需要为模板类定义一个朋友函数。功能具有返回类型是类的成员类型。现在，我无法事先声明它，因为当时尚不知道返回类型。像这样的东西

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

我该怎么做？

我设法在G 上编译了该代码：

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

（因此需要第二个"键入"）

您还需要在参数中说typename：

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

否则，只要所有模板定义出现在之前，您的代码都没有问题。

看来，在您的特定示例中，fcn函数中的任何内容实际上都取决于A类。它甚至不需要访问任何A的方法/字段，既不公开也不受保护/私有。所以这没有道理。否则，这是有道理的，但是无论如何，似乎值得重新思考您的问题，并提出一个不需要这样的黑客的清洁解决方案。如果经过深入思考，您仍然相信自己需要它，您可以做这样的事情：

#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: %dn", fcn(a));
}

在上面的示例中值得注意的是，您需要解开跨依赖关系，并使您的自由功能不取决于A类声明。如果您仍然觉得需要该耦合，则以下代码也有效：

#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: %dn", fcn(a));
}

希望它有帮助。祝你好运！

现在可能会与别人的答案相关，但这是完整，可测试解决方案。最终函数定义是fcn的模板专业化，该模板将产生编译器错误，表明A<double>::x无法从fcn<int>访问，但是A<int>::x IS 可访问。

。 
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;
}
相关文章：