Simulando un parámetro de plantilla

Question

Es imposible asociar un parámetro de plantilla porque el estándar no lo permite. ¿Cómo podría obtener efectivamente lo mismo entonces?

Lo que quiero es básicamente un tipo que no se puede usar fuera del objeto que lo posee. Por qué está más allá del punto, pero si realmente debe saberlo, estoy tratando de formular un conjunto de indicadores inteligentes que respondan al problema de compartir un recurso de propiedad. Por lo tanto lo que estoy tratando de hacer es algo así como así, si ha funcionado:

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

Así, una clase no puede sostener este objeto como un miembro a menos que se declare el propietario, y si es lo suficientemente tonto para exponer como es, será imposible usar fuera de la clase siendo tan estúpido.

Answer 1

Usted podría utilizar esto, y luego deje que todos los propietarios hereden de Propietario.

A continuación, podría utilizar propietario clase privada para envolver los métodos utilizados en accessible_member.
accessible_member ahora está disponible para Propietario. Friend no es heredado, por lo que puede suministrar (ajustar) los métodos necesarios para que todas las clases que hereden Owner puedan usar accessible_member.

Es una solución de 2 niveles pero mantiene el nivel de encapsulado.

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

continuación, puede utilizar la accessible_member indirectamente en estructuras que heredan de propietario a través de los métodos protegidos:

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

Mira el último ejemplo en Template Friends.

Answer 2

¿Qué hay de simplemente definir un tipo anidado privado que trivial hereda de accessible_member? Algo así como

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

Por supuesto que todavía significa que el tipo original accessible_member está disponible para cualquier persona así que no es tal vez de mucha utilidad ahora que lo pienso de ella.

Answer 3

Tiene la razón sobre C++ 98/03. Sin embargo C++ 0x (N3225 11,4/3) le permite hacer esto con la siguiente sintaxis:

friend Owner; 

ver si su compilador permitirá hacer eso. Intente activar el soporte C++ 0x. De lo contrario, las soluciones son más feo:

struct Owner 
{ 
    typedef Owner self; 
}; 

...

A continuación, en función de su compilador uno de:

friend typename Owner::self; 

o:

friend class Owner::self; 

Answer 4

7.1.5.3 p2 dice:

[Nota: esto implica que, dentro de una plantilla clase con un tipo-parámetro de plantilla T, la declaración de clase amigo T; está mal formado.]

Como resultado, cualquier solución que le permita hacerlo de cualquier forma será no conforme.

Answer 5

La única solución que veo es bastante feo y utiliza el 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

que trabajará, con un pequeño cambio, en C++ 98 por lo que yo puedo ver. Se compiló sin ninguna advertencia para mí con g++-4.1 -Wall -Wextra -pedantic -ansi -std=c++98

Sólo cambia

friend Owner; 

a

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

(Tengo esa respuesta en Stackoverflow, esta pregunta ha surgido un par de veces: Template parameter as a friend)