Haciendo un parámetro de plantilla un amigo?

Question

Ejemplo:

template<class T> 
class Base { 
public: 
    Base(); 
    friend class T; 
}; 

Ahora bien, esto no funciona ... ¿Hay una manera de hacer esto?

En realidad estoy tratando de hacer un sellador clase general de esta manera:

class ClassSealer { 
private: 
    friend class Sealed; 
    ClassSealer() {} 
}; 
class Sealed : private virtual ClassSealer 
{ 
    // ... 
}; 
class FailsToDerive : public Sealed 
{ 
    // Cannot be instantiated 
}; 

me encontré con este ejemplo en este sitio en alguna parte, pero no puedo encontrarlo ... (here)

Sé que hay other ways de hacer esto, pero ahora tengo curiosidad si realmente puedes hacer algo como esto.

Answer 1

Está explícitamente prohibido en el estándar, incluso si algunas versiones de VisualStudio lo permiten.

C++ estándar 7.1.5.3 elaborados especificadores de tipo, párrafo 2

3.4.4 describes how name lookup proceeds for the identifier in an elaborated-type-specifier. If the identifier resolves to a class-name or enum-name, the elaborated-type-specifier introduces it into the declaration the same way a simple-type-specifier introduces its type-name. If the identifier resolves to a typedef-name or a template type-parameter, the elaborated-type-specifier is ill-formed. [Note: this implies that, within a class template with a template type-parameter T, the declaration friend class T; is ill-formed. ]

I reconocen el código de seguridad como un patrón para sellar (no permitir la extensión de) una clase. Hay otra solución, que realmente no bloquea la extensión, pero que indicará que se extiende de forma inadvertida desde la clase. Como se ve en ADOBE Source Library:

namespace adobe { namespace implementation { 
template <class T> 
class final 
{ 
protected: 
    final() {} 
}; 
}} 
#define ADOBE_FINAL(X) private virtual adobe::implementation::final<T> 

con el uso:

class Sealed : ADOBE_FINAL(Sealed) 
{//... 
}; 

Mientras que permite la extensión si realmente lo fuerza:

class SealBreaker : public Sealed, ADOBE_FINAL(Sealed) 
{ 
public: 
    SealBreaker() : adobe::implementation::final<Sealed>(), Sealed() {} 
}; 

Será evitar que los usuarios por error hacerlo.

EDITAR:

El novedoso estándar de C++ 11 no le permiten hacerse amigo de un argumento de tipo con una sintaxis ligeramente diferente:

template <typename T> 
class A { 
    // friend class T; // still incorrect: elaborate type specifier 
    friend T;   // correct: simple specifier, note lack of "class" 
}; 

Answer 2

¿Realmente necesita hacer esto? Si desea evitar que alguien provenga de su clase, simplemente agregue un comentario y haga que el destructor no sea virtual.

Answer 3

me encontré con un simple truco para declarar los parámetros de plantilla como amigos:

template < typename T> 
struct type_wrapper 
{ 
    typedef T type; 
}; 


template < typename T> class foo 
{ 
    friend class type_wrapper < T>::type 
}; // type_wrapper< T>::type == T 

Sin embargo, no sé cómo esto podría ayudar a definir una versión alternativa de un sellador de clase .