c++ - descarga - codelite free

Typedef al tipo de entorno en C++

Question

¿Hay alguna manera de construir un typedef dentro de una declaración de tipo al tipo declarado (circundante) sin indicar el nombre del tipo?

Ejemplo:

class X
{
  public:
    typedef <fill in magic here> MyType;
  //...
};

Fondo: Esto parece tonto en el primer vistazo. Necesito esto porque construyo el tiempo de compilación-reflexión de mis clases de datos usando macros. Entonces hay una macro insertada en la declaración de la clase de datos que necesita tratar con el tipo en el que está insertada. Hasta ahora encontré soluciones de trabajo para MSVC y g ++ que dependen de lo que creo que son fallas en la implementación. Por lo tanto, es posible que no funcionen en una versión más nueva. Clang no "come" ninguna de estas soluciones.

Mi solución actual para MSVC define un método y luego toma su dirección solo por su nombre y llama a un pequeño ayudante que "devuelve" el tipo de su clase. (Clang y g ++ esperan el nombre completo del método, incluido su nombre de clase).

Mi solución actual para g ++ define un método estático con el tipo de retorno std::remove_reference(decltype(*this)) . (Clang y MSVC no permiten this en el contexto estático).

Preferiría absolutamente una solución de conformidad estándar, pero una solución especial para clang también estaría bien por el momento.

Si nada funciona, tengo que pasar el nombre de la clase a la macro, pero trato de evitar esto ya que tengo un montón de código usando la macro.

EDITAR : Agregar una muestra sobre cómo funciona la reflexión (que puede aclarar lo que necesito):

class X : public Y
{
  public:
    //.. constructor and such stuff...

    int a;
    double b;
    std::string c;

    CLASSHEAD(Y)
      FIELD(a)
      FIELD(b)
      FIELD(c)
    CLASSFOOT
};

CLASSHEAD es la macro que debe definir typedef . Es una macro VAR_ARGS donde los argumentos reciben las clases base. Como se dijo: es posible darle el nombre de la clase como primer argumento (lo que da como resultado CLASSHEAD(X, Y) en el ejemplo). Pero casi no me puedo imaginar que no haya solución para una tarea tan "simple" como tipificar el tipo de entorno ...

Answer 1

Esto no cumple exactamente con sus especificaciones, pero creo que es bastante cercano:

class X
{
//Stuff...

//Use Macros to add:
struct MyType;

//Use class closing macro to insert variable between class-ending brace and semicolon      


} TYPE_VAR;
//Perhaps add random stuff to TYPE_VAR name to avoid collisions, like __FILE__
struct decltype(TYPE_VAR)::MyType
{
    typedef decltype(TYPE_VAR) V;
};

Luego acceda al tipo de X usando

X::MyType::V

Por ejemplo, un CLASSFOOT simplificado podría verse así:

#define CLASSFOOT /*Your classfoot here*/ } TYPE_VAR; struct decltype(TYPE_VAR)::MyType {typedef decltype(TYPE_VAR) V;
//No }; at end on purpose- this will come from the class in which you placed CLASSFOOT

¿Es esto lo suficientemente bueno para tus propósitos?

Answer 2

Nohting funciona así que usar la clase Nombre en la macro es la única solución de trabajo

Answer 3

Como ya está usando macros, puede usar esta solución https://.com/a/21143997/2173029

#define CLASS_WITH_MY_TYPE(ClassName) / 
    class ClassName                   /
    {                                 /
       using MyType = ClassName;

Y luego usar como

CLASS_WITH_MY_TYPE(X)
public:
  struct Y
  {
    using T = MyType;
  };
};

static_assert(std::is_same<X, typename X::Y::T>::value, "");

Marcado como wiki de la comunidad ya que @Chris mencionó el enlace y la respuesta original fue publicada por @Bartek Banachewicz