与模板参数建立好友关系

Question

不可能将模板参数添加为好友，因为标准不允许这样做。那么我怎样才能有效地得到同样的东西呢？

我想要的基本上是一种在拥有它的对象之外无法使用的类型。为什么不是重点，但如果您确实必须知道，我正在尝试制定一组智能指针来解决共享自有资源的问题。因此，我想要做的事情是这样的，如果它有效的话：

template < typename T, typename Owner >
struct accessible_member
{
private:
  accessible_member() : val(T()) {}
  accessible_member(T const& t) : val(t) {}

  operator T& () { return val; }
  operator T const& () const { return val; }

  member_ptr<T> operator & () { return member_ptr<T>(val); }

  friend class Owner;
};

因此，一个类不能将这个对象作为成员持有，除非它声明自己是所有者，并且如果它足够愚蠢地按原样公开它，那么它将是不可能在课堂外使用，因为太愚蠢了。

Answer 1

您对 C++98/03 的看法是正确的。但是，C++0x (n3225 11.4/3) 允许您使用以下语法执行此操作：

friend Owner;

查看您的编译器是否允许您执行此操作。尝试打开 C++0x 支持。否则，解决方法会更丑陋：

struct Owner
{
    typedef Owner self;
};

...

然后根据您的编译器之一：

friend typename Owner::self;

或：

friend class Owner::self;

Answer 2

您可以使用它，然后让所有所有者继承 Owner。

然后，您可以使用 Owner 类来私有包装 accessible_member 中使用的方法。
所有者现在可以访问accessible_member。 Friend 不是继承的，因此您可以提供（包装）必要的方法，以便所有继承 Owner 的类都可以使用 accessible_member。

这是一个 2 级解决方案，但它保持了封装级别。

template < typename U >
struct Owner 
{
   protected:
   accessible_member<U> newAccessible_member() { return accessible_member<U>(); }
   accessible_member<U> newAccessible_member(U const& u) { return accessible_member<U>(u); }
   .....

};

template < typename T >
struct accessible_member
{
private:
  accessible_member() : val(T()) {}
  accessible_member(T const& t) : val(t) {}

  operator T& () { return val; }
  operator T const& () const { return val; }

  member_ptr<T> operator & () { return member_ptr<T>(val); }


  template < typename U> friend class Owner;
};

然后，您可以使用受保护的方法在从 Owner 继承的结构中间接使用accessible_member：

struct Blah: Owner<int>
{
   void Dosomething() {
       accessible_member<int> blah= newAccessible_member();
   }
};

查看最后一个示例 模板好友。

Answer 3

7.1.5.3 p2 说：

[注意：这意味着，在一个
带有模板的类模板
类型参数 T，声明
朋友等级T；格式不正确。]

因此，任何允许您以任何方式实现的解决方案都将不符合标准。

Answer 4

简单地定义一个从accessible_member继承的私有嵌套类型怎么样？当然

class Owner
{
    template < typename T >
    class accessible_member : public ::accessible_member< T > {};
};

，这仍然意味着原始 accessible_member 类型可供任何人使用，因此考虑起来可能没有多大用处。

Answer 5

我能看到的唯一解决方法相当丑陋，并且使用 CRTP：

template <typename T>
struct CanUseAccessibleMember
{
    template <typename T>
    static const T& get(const accessible_member<T>& m)
    { return static_cast<const T&>(m); }

    // Etc. You can even specialize this class.
};

struct ExampleOwner 
    : protected CanUseAccessibleMember<ExampleOwner>
{
    // Do whatever you want with accessible members here
    // but you have to use the get syntax
};

template <typename T, typename Owner>
class accessible_member
{
    // Implement members as you did

    friend struct CanUseAccessibleMember<Owner>;
};

Answer 6

据我所知，在 C++98 下只要稍加改变就可以了。它编译时没有对我发出任何警告 g++-4.1 -Wall -Wextra -pedantic -ansi -std=c++98

只需更改

friend Owner;

为

struct Wrapper { typedef Owner type; };
friend class Wrapper :: type;

（我在 Stackoverflow 上得到了答案，这个问题已经出现了几次：模板参数作为朋友）