Comment structurez-vous vos fonctions de comparaison?

Question

Je rencontre fréquemment des situations, en particulier avec le tri en C++, où je compare une série de champs afin de comparer une structure plus grande. Un exemple simplifié:

struct Car{ 
    Manufacturer make; 
    ModelName model; 
    Year year; 
}; 

bool carLessThanComparator(const Car & car1, const Car & car2){ 
    if(car1.make < car2.make){ 
     return true; 
    }else if(car1.make == car2.make){ 
     if(car1.model < car2.model){ 
      return true; 
     }else if(car1.model == car2.model){ 
      if(car1.year < car2.year){ 
       return true; 
      } 
     } 
    } 

    return false; 
} 

Mon approche instinctive semble lourde, en particulier pour plus de 3 champs. Comment structureriez-vous cette série de comparaisons en C++? Les autres langues fournissent-elles une syntaxe plus succincte ou élégante?

Answer 1

Eh bien, si votre fonction frappe un retour dans le si clause, il n'y a pas besoin d'un autre explicite, car il aurait déjà renflouées. Cela peut sauver sur la « vallée tiret »:

bool carLessThanComparator(const Car & car1, const Car & car2) { 
    if(car1.make < car2.make) 
     return true; 

    if (car1.make != car2.make) 
     return false; 

    if(car1.model < car2.model) 
     return true; 

    if(car1.model != car2.model) 
     return false; 

    if(car1.year < car2.year) 
     return true; 

    return false; 
} 

J'aime approche court-circuit lispien de MarkusQ ainsi.

Answer 2

bool carLessThanComparator(const Car & car1, const Car & car2){ 
    return (
     (car1.make < car2.make ) or ((car1.make == car2.make ) and 
     (car1.model < car2.model) or ((car1.model == car2.model) and 
     (car1.year < car2.year ) 
    ))); 

- MarkusQ

Answer 3

Si cela se produit beaucoup vous pouvez mettre un modèle comme celui-ci dans un collecteur commun:

template<typename T, typename A1, typename A2, typename A3> 
bool 
do_less_than(
     const typename T& t1, 
     const typename T& t2, 
     const typename A1 typename T::* a1, 
     const typename A2 typename T::* a2, 
     const typename A3 typename T::* a3) 
{ 
    if ((t1.*a1) < (t2.*a1)) return true; 
    if ((t1.*a1) != (t2.*a1)) return false; 
    if ((t1.*a2) < (t2.*a2)) return true; 
    if ((t1.*a2) != (t2.*a2)) return false; 
    return (t1.*a3) < (t2.*a3); 
} 

Ajouter d'autres modèles pour différents nombres d'arguments selon les besoins. Pour chaque moins de fonction, vous pouvez faire quelque chose comme ceci:

bool carLessThanComparator(const Car& car1, const Car& car2) 
{ 
    return do_less_than(car1, car2, &Car::make, &Car::model, &Car::year); 
} 

Answer 4

Personnellement, je le == passer outre, <,>, et tous les autres opérateurs nécessaires. Cela permettrait de nettoyer le code, pas dans la comparaison, mais quand vous avez besoin de faire la comparaison. Pour la comparaison elle-même, je l'écrirais de la même manière que Crashworks.

bool operator<(const Car &car1, const Car &car2) { 
    if(car1.make < car2.make) 
     return true; 
    if(car1.make != car2.make) 
     return false; 
    if(car1.model < car2.model) 
     return true; 
    if(car1.model != car2.model) 
     return false; 
    return car1.year < car2.year; 
} 

Answer 5

Personnellement, je vous suggère de ne pas utiliser le = ou == opérateurs comme nous semblent recommander ici - cela exige que les arguments/membres d'avoir les deux opérateurs moins égaux alors et juste pour faire moins de vérifier une classe les contenant - en utilisant seulement l'opérateur less than est suffisant et vous permettra d'économiser la redondance et les défauts potentiels dans le futur.

Je vous suggère d'écrire:

bool operator<(const Car &car1, const Car &car2) 
{ 
    if(car1.make < car2.make) 
     return true; 
    if(car2.make < car1.make) 
     return false; 

    if(car1.model < car2.model) 
     return true; 
    if(car2.model < car1.model) 
     return false; 

    return car1.year < car2.year; 
} 

Answer 6

Je me demandais la même chose que l'OP et sommes tombés sur cette question. Après avoir lu les réponses, j'ai été inspiré par janm et RnR pour écrire une fonction de modèle lexicographicalMemberCompare qui utilise seulement operator< sur les membres comparés. Il utilise également boost::tuple afin que vous puissiez spécifier autant de membres que vous le souhaitez. Le voici:

#include <iostream> 
#include <string> 
#include <boost/tuple/tuple.hpp> 

template <class T, class Cons> 
struct LessThan 
{ 
    static bool compare(const T& lhs, const T& rhs, const Cons& cons) 
    { 
     typedef LessThan<T, typename Cons::tail_type> NextLessThan; 
     typename Cons::head_type memberPtr = cons.get_head(); 
     return lhs.*memberPtr < rhs.*memberPtr ? 
      true : 
      (rhs.*memberPtr < lhs.*memberPtr ? 
       false : 
       NextLessThan::compare(lhs, rhs, cons.get_tail())); 
    } 
}; 

template <class T> 
struct LessThan<T, class boost::tuples::null_type> 
{ 
    static bool compare(const T& lhs, const T& rhs, 
         const boost::tuples::null_type& cons) 
    { 
     return false; 
    } 
}; 

template <class T, class Tuple> 
bool lexicographicalMemberCompare(const T& lhs, const T& rhs, 
            const Tuple& tuple) 
{ 
    return LessThan<T, typename Tuple::inherited>::compare(lhs, rhs, tuple); 
} 

struct Car 
{ 
    std::string make; 
    std::string model; 
    int year; 
}; 

bool carLessThanCompare(const Car& lhs, const Car& rhs) 
{ 
    return lexicographicalMemberCompare(lhs, rhs, 
     boost::tuples::make_tuple(&Car::make, &Car::model, &Car::year)); 
} 

int main() 
{ 
    Car car1 = {"Ford", "F150", 2009}; 
    Car car2 = {"Ford", "Escort", 2009}; 
    std::cout << carLessThanCompare(car1, car2) << std::endl; 
    std::cout << carLessThanCompare(car2, car1) << std::endl; 
    return 0; 
} 

Espérons que cela soit utile à quelqu'un.

Answer 7

Je sais qu'il est une vieille question, mais pour les futurs visiteurs: moderne C++ 11 solution est d'utiliser std::tie

struct Car{ 
    Manufacturer make; 
    ModelName model; 
    Year year; 
}; 

bool operator<(Car const& lhs, Car const& rhs) 
{ 
    return std::tie(lhs.make, lhs.model, lhs.year) < std::tie(rhs.make, rhs.model, rhs.year); 
} 

std::tie convertit le struct en std::tuple afin que les délégués de l'opérateur de comparaison ci-dessus à std::tuple::operator< . Ceci à son tour fait une comparaison lexicographique par rapport à l'ordre dans lequel les membres sont rassemblés en std::tie.

La comparaison lexicographique est court-circuitée de la même manière que dans les autres solutions à cette question. Mais il est même assez succinct pour définir à la volée dans une expression C++ lambda. Pour les classes avec des membres de données privés, il est préférable de définir la fonction friend dans la classe.