Envoltura semántica del tipo C++

Question

Tengo un tipo de datos, por ejemplo, class Vector3. Ahora necesito crear varias clases con la misma interfaz que Vector3, pero con semántica de nivel superior (por ejemplo: Position, Velocity). Usar typedef no es suficiente, porque necesito que estos tipos sean distintos para que se puedan usar para sobrecargar. En C++ 0x probablemente podría usar la herencia del constructor:

struct Position: public Vector3 { 
    using Vector3::Vector3; 
}; 

¿Podría haber algún problema con esto? ¿Hay alguna forma mejor de hacerlo? ¿Es posible hacerlo sin usar las características C++ 0x y no tener que escribir explícitamente todos los constructores Vector3?

Answer 1

Considere el uso de una estructura de etiquetas

struct tagPosition {}; 
struct tagDirection {}; 
struct tagGeneric {}; 

namespace detail 
{ 
    template <typename Tag=tagGeneric> 
     class Vector3 
    { 
     // business as usual 
    }; 
} 

typedef detail::Vector3<tagPosition> Position; 
typedef detail::Vector3<tagDirection> Direction; 
typedef detail::Vector3<tagGeneric> Vector3; 

Para los puntos de bonificación, tienen los operadores de conversión/constructores:.

template <typename Tag=tagGeneric> 
     class Vector3 
    { 
     template <typename OtherTag> 
      explicit Vector3(const Vector3<OtherTag>& rhs) { /* ... */ } 

//  template <typename OtherTag> 
//   operator Vector3<OtherTag>() const { return /* ... */ } 
    }; 

Si te gusta vivir peligrosamente le puede descartar la palabra clave explicit o habilitar el operador de conversión implícita. Esto tendría el 'beneficio' de ser capaz de permitir que promiscuos resoluciones operador de este modo:

Position pos; 
Direction dir; 
Generic gen; 

dir = gen + pos; // you see why I call it 'promiscuous'? 

Me gustaría recomendar (lugar) para definir los operadores explícitas para casos como este (funciones gratuitas :)

Position operator+(const Position& v, const Translation& d) { /* .... */ } 

De esta forma, su modelo de clase refleja la semántica de sus clases.

C++0x would possibly contain things to enable explicit conversion operators, IIRC:

En el caso de los constructores conversión, puede desactivar las conversiones implícitas al declarar el constructor tan explícito El N1592 proposal extiende la semántica de esta palabra clave para todos los operadores de conversión. Un operador de conversión declarado explícito no realizará una conversión implícita. En su lugar, el programador tendrá que llamar explícitamente

Answer 2

Cuando he necesitado tipos diferenciados pero-similares que he usado generalmente un parámetro ficticio plantilla, como (fruto de la casualidad, sin tocar por las manos sucias del compilador)

template< class UniqueId > 
struct Blah {}; 

typedef Blah< struct AlphaId > Alpha; 
typedef Blah< struct BetaId > Beta; 

Esto puede o no puede ser Que necesitas.

Saludos & HTH,