Crea puntatore al membro per il tipo di valore della mappa in vc2010

Question

Abbiamo riscontrato un problema nel porting del nostro codice alla versione meno recente 2010 di VC++.

I problemi è causato dalla realizzazione di mappa in VC che si traduce in un derivato a base conversione di un pointer-to-member in un non-type-argument venga richiesto:

#include <map> 
#include <algorithm> 

template <typename MapValueType, int MapValueType::*var> 
bool f (MapValueType const & v); 

int main() 
{ 
    typedef std :: map<int, int> MapType; 
    MapType m; 
    std :: find_if (m.begin() 
     , m.end() 
     , f<MapType::value_type, & MapType::value_type::second>); 
} 

Il seguente messaggio viene generato:

La conversione standard da puntatore a membro di base a puntatore-membro di derivato non viene applicata per gli argomenti modello file.cc (x): errore C2973: 'f': argomento modello non valido 'int std :: _ Pair_base < _Ty1, _Ty2> :: * '

Così sembra che l'attuazione di value_type nel std::map ha la coppia in una classe base.

Qualche idea su come risolvere questo e mantenere il pointer-to-member come non-type-argument?

La nostra unica opzione è modificare la struttura in modo che f sia un con un membro pointer-to-member?

Answer 1

A condizione che il codice dovrebbe compilare IMO (e lo fa su GCC 4.7. 2 e Clang 3.2), credo che il tuo design sia inutilmente intricato. A pair ha solo due variabili membro, quindi si accederà al primo o al secondo.

Non vedo la necessità di un oggetto funtore: basta usare un argomento del modello booleano per determinare se il codice deve funzionare su first o sulla variabile membro second. Ecco una possibilità:

#include <map> 
#include <algorithm> 

template <typename MapValueType, bool first> 
bool f (MapValueType const & p) 
{ 
    auto& v = (first) ? p.first : p.second; 
    // ... do your work on v ...  
} 

int main() 
{ 
    typedef std :: map<int, int> MapType; 
    MapType m; 

    // Will work on the `first` member 
    std::find_if(m.begin(), m.end(), f<MapType::value_type, true>); 

    // Will work on the `second` member 
    std::find_if(m.begin(), m.end(), f<MapType::value_type, false>); 
} 

Se davvero non si può modificare il codice cliente né il codice all'interno della funzione f(), allora si potrebbe andare per questa specifica-VS2010 mod:

// Add "_MyBase" here... works, but ugly IMO 
template <typename MapValueType, int MapValueType::_Mybase::* var> 
bool f(MapValueType const & v); 

// And the client side could stay unchanged... 
int main() 
{ 
    typedef std :: map<int, int> MapType; 
    MapType m; 
    std::find_if(
     m.begin(), 
     m.end(), 
     f<MapType::value_type, &MapType::value_type::second> 
     ); 
} 

Infine, se il il codice deve compilare su altre piattaforme e tutti i vincoli sulla non modificabilità del codice della funzione e del client ancora in attesa, quindi è possibile definire una macro del preprocessore che si espande a _Mybase:: per VS2010 e alla stringa vuota per altri compilatori.

Answer 2

Perché insisti a mantenere il puntatore al membro come parametro/argomento del modello non di tipo?

In ogni caso, penso che si potrebbe usare questo, se si può essere limitato a Visual Studio 2010 o compilatori con decltype()

template <typename Class, typename Type> 
Class 
get_class_type (Type Class:: *); 
//... 
it = std::find_if(m.begin(), m.end(), 
    f<decltype(get_class_type(&MapType::value_type::second)), &MapType::value_type::second>);