decltype y el operador de ámbito en C++

Question

Necesito obtener el tipo que se proporcionó al crear una instancia de una plantilla. Considere el siguiente ejemplo:

template <typename T> struct Foo 
{ 
    typedef T TUnderlying; 
}; 

static Foo<int> FooInt; 

class Bar 
{ 
public: 
    auto Automatic() -> decltype(FooInt)::TUnderlying 
    { 
    return decltype(FooInt)::TUnderlying(); 
    } 
}; 

int main() 
{ 
    Bar bar; 
    auto v = bar.Automatic(); 
    return 0; 
} 

El problema con este código es utilizar el operador de ámbito junto con decltype. Visual C++ 2010 se queja así:

error C2039: 'TUnderlying': no ​​es un miembro de '`espacio de nombres global''

Reuní algo de información sobre el tema en la Wikipedia:

Al comentar el borrador del Comité formal para C++ 0x, el miembro miembro de ISO japonés señaló que "un operador de ámbito (:) no se puede aplicar a decltype, pero debería serlo. Sería útil en el caso obtener el tipo de miembro (anidado) tipo) de una instancia como sigue ": [16]

vector<int> v; 
decltype(v)::value_type i = 0; // int i = 0; 

Esto y otros problemas similares fueron abordados por David Vandevoorde, y votaron en el documento de trabajo en marzo de 2010.

Así que creo que el Visual C++ 2010 no tiene esto implementado. Se me ocurrió esta solución alternativa:

template <typename T> struct ScopeOperatorWorkaroundWrapper 
{ 
    typedef typename T::TUnderlying TTypedeffedUnderlying; 
}; 

auto Automatic() -> ScopeOperatorWorkaroundWrapper<decltype(FooInt)>::TTypedeffedUnderlying 
{ 
    return ScopeOperatorWorkaroundWrapper<decltype(FooInt)>::TTypedeffedUnderlying(); 
} 

¿Extraño alguna solución que sea más elegante y menos detallada?

Answer 1

Esto reemplaza de forma transparente la palabra clave decltype con la solución basada en la plantilla. Una vez que ya no es necesario para apoyar MSVC2010 puede quitar la definición de la macro sin cambiar ningún código de usuario:

#if _MSC_VER == 1600 
#include <utility> 
#define decltype(...) \ 
    std::identity<decltype(__VA_ARGS__)>::type 
#endif 

que permite a este compilar y trabajar en MSVC10:

std::vector<int> v; 
decltype(v)::value_type i = 0; 

---

Tenga en cuenta que std::identity no es parte del estándar de C++, pero es seguro confiar aquí ya que la solución está limitada a un compilador que incluye std::identity en su implementación de biblioteca estándar.

Answer 2

La solución se ve relativamente bien, pero no es extensible y los nombres son horribles . ¿Por qué no usar id?

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

Y luego:

id<decltype(FooInt)>::type::TUnderlying; 

no probado, pero debería funcionar.

---

igual que en, demasiado prolijo y aunque ellos describen que es una solución, esto puede ser redundante y no una información útil en la mayoría de las situaciones.

Answer 3

Como alternativa, se puede tirar fácilmente el tipo a cabo utilizando una plantilla de función auxiliar:

template <typename T> struct Foo 
{ 
    typedef T TUnderlying; 
}; 

static Foo<int> FooInt; 

template <typename T> 
typename Foo<T>::TUnderlying foo_underlying(Foo<T> const &) 
{ 
    return typename Foo<T>::TUnderlying(); 
} 

class Bar 
{ 
public: 
// auto Automatic() -> decltype(FooInt)::Underlying 
// { 
//  return decltype(FooInt)::Underlying; 
// } 
    auto Automatic() -> decltype(foo_underlying(FooInt)) 
    { 
     return foo_underlying(FooInt); 
    } 
}; 

int main() 
{ 
    Bar bar; 
    auto v = bar.Automatic(); 
}