Est-il possible d'exécuter des algorithmes standard sur le vecteur <MyType> d'une manière élégante?

Question

Je sais que si j'ai un vector<int> je peux exécuter des algorithmes sur elle comme ceci:

int max = *max_element(myints.begin(), myints.end()); 

Mais si j'ai un vector<MyStruct> où l'un des champs de la struct est un entier. Existe-t-il une manière élégante et élégante d'exécuter un algorithme sur les entiers de toutes mes structures?

Answer 1

Fournir un comparateur à max_element:

MyStruct max = *max_element(v.begin(), v.end(), 
    [](const MyStruct & lhs, const MyStruct & rhs) { return lhs.theInt < rhs.theInt; }); 

Si votre compilateur ne supporte pas encore lambdas, vous devrez écrire une fonction distincte ou la fonction classe d'objet.

Sinon, si vous surchargez operator< pour votre classe pour faire ce même comparaison, alors vous pouvez simplement faire ceci:

MyStruct max = *max_element(v.begin(), v.end()); 

Answer 2

Pour les structures, vous pouvez définir une fonction ou un objet de comparaison. Vous pouvez également définir l'opérateur < pour votre structure. Voici un example.

Answer 3

Cela dépend de votre définition de « élégante » est, mais oui, cela peut être terminé. En fait, de nombreuses façons différentes.

En standard C++, vous pouvez utiliser un Functor:

#include <algorithm> 
#include <vector> 
#include <functional> 
using namespace std; 

class Gizmo 
{ 
public: 
    int n_; 
}; 

class BiggestGizmo : public std::binary_function<bool, Gizmo, Gizmo> 
{ 
public: 
    bool operator()(const Gizmo& lhs, const Gizmo& rhs) const 
    { 
     return lhs.n_ > rhs.n_; 
    } 
}; 

int main() 
{ 
    typedef vector<Gizmo> Gizmos; 
    Gizmos gizmos; 
    Gizmos::const_iterator it = max_element(gizmos.begin(), gizmos.end(), BiggestGizmo()); 
} 

En C++ 0X, vous pouvez utiliser un Lambda:

#include <algorithm> 
#include <vector> 
using namespace std; 

class Gizmo 
{ 
public: 
    int n_; 
}; 

int main() 
{ 
    typedef vector<Gizmo> Gizmos; 
    Gizmos gizmos; 
    Gizmos::const_iterator it = max_element(gizmos.begin(), gizmos.end(), [](const Gizmo& lhs, const Gizmo& rhs) -> bool 
    { 
     return lhs.n_ > rhs.n_; 
    }); 
} 

Answer 4

Comme vous l'avez dit dans l'un des commentaires que vous avez beaucoup de membres de la classe et veulent aborder chacun individuellement dans les algorithmes. Vous vous retrouvez avec différentes possibilités

• lambdas partout (soit Phoenix ou 11 C++)
• foncteurs pour tous les cas
• fonctions membres pour tous les cas

Je préfère la dernière deux solutions seulement si j'avais besoin de répéter le lambdas dans différents endroits (ou si je devais utiliser Phoenix, mais c'est juste une chose personnelle).

struct Foo { 
    int a; 
    int b; 
    bool less_than_by_a(const Foo&) const; 
    bool less_than_by_b(const Foo&) const; 
}; 

std::max_element(begin, end, std::mem_fun_ref(&Foo::less_than_by_a)); 
std::max_element(begin, end, std::mem_fun_ref(&Foo::less_than_by_b)); 

Answer 5

Une autre option dans le mélange: vous pourriez écrire une classe itérateur de votre propre dont les types référence et la valeur sont int& et int, mais qui agit sur le dessus d'un itérateur avec le type de référence MyStruct&, l'accès à ce domaine .

Il est un peu plus de travail que la simple fourniture d'un comparateur supplémentaire pour max_element, mais si vous le faites une fois, vous avez fait pour tous algorithmes, pas seulement ceux qui agissent par l'intermédiaire d'un comparateur. Si vous pouvez l'utiliser, boost::transform_iterator gérera le passe-partout pour vous.

boost::transform_iterator ne vous permet pas de récupérer l'itérateur sous-jacent d'une instance, mais dans le cas de vector cela n'a pas trop d'importance car c'est un accès aléatoire, donc il est efficace de calculer la distance et de l'appliquer à la begin() itérateur.