std :: sort et std :: problème unique avec une struct

Question

Le code suivant:

#include <vector> 
#include <algorithm> 

struct myStructDim 
{ 
    int  nId; 
    int  dwHeight; 
    int  dwWidth; 
};  

void main() 
{ 
    ::std::vector<myStructDim> m_vec_dim; 

    ::std::sort(m_vec_dim.begin(), m_vec_dim.end()); 
    m_vec_dim.erase(
     ::std::unique(m_vec_dim.begin(), m_vec_dim.end()), 
     m_vec_dim.end() 
     ); 
} 

ne compilera pas avec beaucoup d'erreurs, telles que:

erreur C2784: « bool std: : opérateur == (const std :: vecteur < _Ty, _Alloc> &, const std :: vector < _Ty, _Alloc> &) ': ne pouvait pas déduire un argument de modèle pour ' const std :: vector < _Ty, _Allo c> & "de « myStructDim »

Je comprends que je dois remplacer un opérateur ou deux.

Lesquels et comment exactement s'il vous plaît?

Merci pour le soutien!

Answer 1

Vous avez besoin d'opérateurs de comparaison pour exprimer les relations "inférieur à" et "égalité". Définir les fonctions booléennes autonomes operator< et operator== qui prennent deux arguments, chacun const myStructDim&, et effectuent la comparaison exactement comme vous le souhaitez, est probablement plus simple que de définir comme méthodes dans le struct.

Answer 2

Vous avez besoin d'une forme de fonction de comparaison pour sort, et vous avez besoin d'une forme de fonction d'égalité pour unique.

Answer 3

Comme d'autres mentionné l'opérateur < et l'opérateur == ferait l'affaire mais je préfère habituellement passer un prédicat de comparaison.

J'utilise C++ 0x lambdas dans cet exemple mais il peut être implémenté sans cela.

std::sort(
     vec_dim.begin(), 
     vec_dim.end(), 
     [] (myStructDim const & l, myStructDim const & r) {return l.nId < r.nId;} 
    ); 

    vec_dim.erase( 
     std::unique(
     vec_dim.begin(), 
     vec_dim.end(), 
     [] (myStructDim const & l, myStructDim const & r) {return l.nId == r.nId;} 
     ), 
     vec_dim.end() 
    ); 

Answer 4

N'est-il pas possible d'avoir une sorte d'unique sans avoir l'operato>? Je veux dire que je peux comprendre que pour unique j'ai besoin d'un opérateur == (comme les pommes ne sont pas des chaises) mais pourquoi une chaise devrait-elle être plus grande qu'une pomme ??? Je devrais implémenter un opérateur pour certains objets où cela n'a aucun sens! peut-être qu'une sorte de clusering aurait plus de sens. ai donc décidé de mettre en œuvre ce que la question est pour moi-même ici est à mon avis une solution qui est plus logique:

modèle inline void ( listType uniques In, Out listType &) { Out.resize (En .Taille()); std :: copy (In.begin(), In.end(), Out.begin()); listtype :: iterator it = Out.begin(); listtype :: iterator it2 = Out.begin(); it2 ++; int tmpsize = Out.size();

while(it!=Out.end()) 
    { 
    it2 = it; 
    it2++; 
    while((it2)!=Out.end()) 
     { 
     if ((*it)==(*it2)) 
      Out.erase(it2++); 
     else 
      ++it2; 
     } 
    it++; 

    } 
} 

peut-être pas la meilleure solution, mais pour l'instant je ne sais pas

supérieurs