2011-03-07 17 views
10

¿Hay un objeto función incorporada que devuelve p->first y p->second, por lo que con mucho gusto puedo escribirC++ objeto de función para volver `p> first` y` p> second`

transform(m.begin(),m.end(),back_inserter(keys),get_first); 
transform(m.begin(),m.end(),back_inserter(vals),get_second); 

solución basada en STL es la mejor, la solución boost es la segunda mejor opción.

Sí, sé boost::lambda, no quiero comenzar a usarlo.

+1

Parece que has se dio cuenta de que no existe soporte directo en el STL (o supuestamente impulso), ¿por qué no escribir una plantilla de función simple para hacer esto por usted? está obligado a ser más claro que el enfoque 'bind' o el enfoque no estándar ... – Nim

+1

@Nim, esa es probablemente una buena idea, sin embargo, siempre tengo miedo de que todos en el equipo creen su propia versión de 'littleTidbitMissingFromSpec', así que si pudiera encontrar algo sólido en boost, sería mejor. –

+0

¡un espacio de nombres utils (o aux) bien documentado es lo que necesita! ;) – Nim

Respuesta

9

Hay extensiones no estándar para g++ y SGI llamadas select1st y select2nd. Entonces, probablemente no haya nada en el STL para eso. se unen

de Boost puede también hacer eso, le dan un puntero a la función miembro correcta

boost::bind(&std::map<string,string>::value_type::second,_1) 
2

Si puede utilizar C++ 0x se puede utilizar lambdas reales desde G ++ 4.5 o puede utilizar la nueva tuple-library que es totalmente compatible con std :: pairs. Entonces podría usar std :: get < 0> para first y std :: get < 1> para second.

Si está vinculado a C++ 98 puede usar std :: tr1 :: tuple en lugar de std :: pair, ya que en TR1 get no funciona con std :: pair.

También puede usar vincular desde TR1 (tr1/funcional) como lo describió Elazar.

4

Podemos escribir fácilmente un select1st y select2nd:

struct select1st 
{ 
    template< typename K, typename V > 
    const K& operator()(std::pair<K,V> const& p) const 
    { 
     return p.first; 
    } 
}; 

struct select2nd 
{ 
    template< typename K, typename V > 
    const V& operator()(std::pair<K,V> const& p) const 
    { 
     return p.second; 
    } 
}; 

Aquí es una versión alternativa, en realidad más flexible:

struct select1st 
{ 
    template< typename P > 
    typename P::first_type const& operator()(P const& p) const 
    { 
     return p.first; 
    } 
}; 

struct select2nd 
{ 
    template< typename P > 
    typename P::second_type const& operator()(P const& p) const 
    { 
     return p.second; 
    } 
}; 

posteriormente:

transform(m.begin(),m.end(),back_inserter(keys), select1st()); 
transform(m.begin(),m.end(),back_inserter(vals), select2nd()); 
Cuestiones relacionadas