decltype e l'operatore scope in C++

Question

Ho bisogno di ottenere il tipo che è stato fornito durante l'istanziazione di un modello. Considerare il seguente esempio:

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; 
} 

Il problema con questo codice utilizza l'operatore di ambito insieme a decltype. Visual C++ 2010 si lamenta così:

errore C2039: 'TUnderlying': non è un membro di '`namespace globale''

ho raccolto alcune informazioni sul tema su Wikipedia:

Commentando il Draft di commissione formale per C++ 0x, il membro del membro ISO giapponese ha osservato che "un operatore di ambito (: :) non può essere applicato a decltype, ma dovrebbe essere. Sarebbe utile nel caso di ottenere il tipo di membro (nidificato- tipo) da un'istanza come segue ": [16]

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

Questo e altri problemi simili sono stati affrontati da David Vandevoorde e votati nel documento di lavoro nel marzo 2010.

Quindi penso che il Visual C++ 2010 non lo abbia implementato. Mi è venuta in mente questa soluzione:

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

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

Ho perso una soluzione più elegante e meno dettagliata?

Answer 1

Sostituisce in modo trasparente la parola chiave decltype con la soluzione alternativa basata sul modello. Una volta che non è più necessario sostenere MSVC2010 è possibile rimuovere la definizione della macro senza modificare il codice utente:

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

che permette questo per compilare e lavorare su MSVC10:

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

---

noti che std::identity non fa parte dello standard C++, ma è sicuro affidarsi qui in quanto la soluzione è limitata a un compilatore che include std::identity nella sua implementazione di libreria standard.

Answer 2

La soluzione alternativa è relativamente buona ma non è estensibile ei nomi sono orribili . Perché non utilizzare id?

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

E poi:

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

testato, ma dovrebbe funzionare.

---

Come in, troppo prolisso e benché descrivono che è una soluzione, questo può essere ridondante e non un'informazione utile nella maggior parte delle situazioni.

Answer 3

In alternativa, si può facilmente estrarre il tipo utilizzando un modello di funzione di supporto:

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(); 
}