Cómo tener un conjunto de estructuras en C++

Question

Tengo una estructura que tiene una clave única. Quiero insertar instancias de estas estructuras en un conjunto. Sé que para hacer esto, el operador < tiene que estar sobrecargado para que el conjunto pueda hacer una comparación para hacer la inserción.

El siguiente no funciona:

#include <iostream> 
#include <set> 
using namespace std; 
struct foo 
{ 
     int key; 
}; 

bool operator<(const foo& lhs, const foo& rhs) 
{ 
     return lhs.key < rhs.key; 
} 

set<foo> bar; 

int main() 
{ 
    foo *test = new foo; 
    test->key = 0; 
    bar.insert(test); 
} 

Answer 1

Esto podría ayudar:

struct foo 
{ 
    int key; 
}; 

inline bool operator<(const foo& lhs, const foo& rhs) 
{ 
    return lhs.key < rhs.key; 
} 

Si está utilizando espacios de nombres, es una buena práctica para declarar la función operator<() en el mismo espacio de nombres.

---

En aras de la exhaustividad después de su edición, y como otros han señalado, que está intentando añadir un foo* donde se espera una foo.

Si realmente desea tratar con punteros, puede ajustar el foo* en una clase de puntero inteligente (auto_ptr, shared_ptr, ...).

Pero tenga en cuenta que en ambos casos, pierde el beneficio de la operator< sobrecargada que opera en foo, no en foo*.

Answer 2

struct Blah 
{ 
    int x; 
}; 

bool operator<(const Blah &a, const Blah &b) 
{ 
    return a.x < b.x; 
} 

... 

std::set<Blah> my_set; 

Sin embargo, no me gusta la sobrecarga operator< menos que hace sentido intuitivo (¿realmente tiene sentido decir que uno Blah es "menor que" otra Blah?). Si no es así, por lo general proporcionan una función personalizada en lugar comparador:

bool compareBlahs(const Blah &a, const Blah &b) 
{ 
    return a.x < b.x; 
} 

... 

std::set<Blah,compareBlahs> my_set; 

Answer 3

ver la respuesta de Ereon, que está bien.

El verdadero problema en que este código es:

foo *test = new foo; 
test->key = 0; 
bar.insert(test); 

inserta un punteroen el conjunto, no una estructura. Cambiar el insert a:

bar.insert(*test); 
//  ^

---

EDIT: pero entonces tendrá que delete foo, ya que se copiará en el set. O simplemente crear en la pila (usando set con punteros no es una buena idea, porque la disposición será "extraña" - el set clasificará de acuerdo a las direcciones de los punteros)

Answer 4

Puede sobrecargar el operator < dentro de la clase como también,

struct foo 
{ 
    int key; 
    bool operator < (const foo &other) const { return key < other.key; } 
}; 

En su pregunta, si desea utilizar set<foo> bar; como la declaración a continuación, se debe insertar un valor que,

bar.insert(*test); 

Pero eso no va a ser una buena idea, como yo Estás haciendo una copia redundante.

Answer 5

Lo mejor que puede hacer es dar un constructor foo:

struct foo 
{ 
    foo(int k) : key(k) { } 
    int key; 
}; 

A continuación, a añadir, en lugar de ...

foo *test = new foo; 
test->key = 0; 
bar.insert(test); // BROKEN - need to dereference ala *test 
// WARNING: need to delete foo sometime... 

... puede simplemente usar:

bar.insert(foo(0)); 

Answer 6

El problema no está en su conjunto; está en tu objeto test. Estás usando el estilo Java allí. En C++, sólo escribimos:

set<foo> bar; 

int main() 
{ 
    foo test; // Local variable, goes out of scope at } 
    test.key = 0; 
    bar.insert(test); // Insert _a copy of test_ in bar. 
}