Friending a template parameter

Question

It's impossible to friend a template parameter because the standard disallows it. How might I get effectively the same thing then?

What I want is basically a type that is unusable outside the object which owns it. Why is rather beside the point but if you really must know, I'm trying to formulate a set of smart pointers that answer the problem of sharing an owned resource. Thus what I'm looking to do is something like so, if it worked:

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

Thus a class can't hold this object as a member unless it declares itself the owner, and if it's silly enough to expose it as is, it will be impossible to use outside the class being so stupid.

Answer 1

You are correct about C++98/03. However C++0x (n3225 11.4/3) allows you to do this with this syntax:

friend Owner;

See if your compiler will let you do that. Try turning on C++0x support. Otherwise the workarounds are uglier:

struct Owner
{
    typedef Owner self;
};

...

Then depending on your compiler one of:

friend typename Owner::self;

or:

friend class Owner::self;

Answer 2

You could use this, and then let all the owners inherit from Owner.

You could then use Owner class to wrap privately the methods used in accessible_member.
accessible_member is now accessible to Owner. Friend is not inherited, so you can supply (wrap) the necessary methods so all the classes that inherit Owner can use accessible_member.

It's a 2 level solution but it keeps the level of encapsulation.

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

Then you can use the accessible_member indirectly in structs that inherit from Owner using the protected methods:

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

Look at the last example at Template Friends.

Answer 3

7.1.5.3 p2 says:

[Note: this implies that, within a class template with a template type-parameter T, the declaration friend class T; is ill-formed.]

As a result, any solution that allows you to it by any mean will be non standard conformant.

Answer 4

What about simply defining a private nested type that trivially inherits from accessible_member? Something like

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

Of course that still means the original accessible_member type is available to anyone so it's maybe not of much use come to think of it.

Answer 5

The only workaround I can see is rather ugly and uses the 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

That will work, with a little change, under C++98 as far as I can see. It compiled without any warnings for me with g++-4.1 -Wall -Wextra -pedantic -ansi -std=c++98

Just change

friend Owner;

to

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

(I got that answer on Stackoverflow, this question has come up a few times: Template parameter as a friend )