Estoy escribiendo algunas funciones auxiliares para un proyecto en el que estoy trabajando. Siempre quise un tipo de operador. Sé que no existe en mi IDE actual (visual studio '10), así que estoy tratando de escribir una implementación para él. Debería funcionar algo como esto:

auto var = new typeof(<expression>);

Debería ser un tipo recuperable en tiempo de compilación basado en la expresión y debería ser posible. C ++ usa esto cuando induce argumentos de plantilla, por ejemplo:

template< typename A >
void foo(A unused) { 
/*  can be invoked like foo(5) with A = int     */
    typedef A type;
    type * used = new type;
}

Así que pensé que podría jugar con macros, clases y plantillas ... algo como esto:

#define typeof(expression)  (_type_creater().inducer(expression)::type)

template<typename T>
class _type_holder{
public:
    typedef T type;
};

class _type_creater{
public:
template< class B >
    _type_holder<B> inducer(B _temp) {
        /*  Here compiler induces the templated expression and creates a typename out of it.
            this we can use extract typename from _type_holder, except a instantiatet type apparantly
            doesn't have access to typedef'd typenames.
        */
        return _type_holder<B>();
    }
};

Entonces, el problema es básicamente que esto es ilegal:

struct a
{
   typedef int type;
}
...
a mya;
new mya::type; //or mya.type

Entonces, la primera pregunta es, ¿por qué es ilegal? ¿Por qué no puede recuperar los tipos de tipos de instancias de tipos? Segunda pregunta, ¿puedo hacer esto en absoluto? Intenté buscar un TYPEOF de refuerzo, pero no pude encontrarle mucho sentido, y parece que solo utiliza errores en los compiladores de VC ("// característica de error específica de VC7.0", "// característica de error específica de VC8.0", "/ / Esto usa buenas características de error de VC6.5 y VC7.1 "). ¿No tengo suerte?

0
Shaggi 23 mar. 2012 a las 05:22
3
" Siempre quise un operador typeof. Sé que no existe en mi IDE actual (visual studio '10) " Sí, se llama decltype.
 – 
ildjarn
23 mar. 2012 a las 05:25
Te quiero gracias. No sé cómo lo pasé por alto. ¿En cuanto a la primera pregunta, sin embargo ...?
 – 
Shaggi
23 mar. 2012 a las 05:28
No sé qué respuesta estás buscando. La sintaxis es ilegal. ¿Quiere saber por qué es ilegal? No creo que nadie que no esté en el comité de ISO C ++ pueda responder razonablemente a esa pregunta.
 – 
ildjarn
23 mar. 2012 a las 05:37
Dado el ejemplo anterior, es legal hacer un :: tipo, pero no mya :: tipo. Sí, supongo que me pregunto por qué, ¿quizás hay una razón lógica detrás de esto?
 – 
Shaggi
23 mar. 2012 a las 05:45
Tal vez, pero dudo que alguien que sepa ese motivo publique aquí.
 – 
ildjarn
23 mar. 2012 a las 05:45

1 respuesta

La mejor respuesta

Un objeto no es un ámbito. El operador de resolución de alcance (::) solo es aplicable a alcances (alcance de clase, alcance de espacio de nombres, alcance global (espacio de nombres)). Di un poco de información adicional como teoría en un comentario sobre la pregunta.

0
Xeo 23 mar. 2012 a las 05:53