Durante años han estado utilizando el siguiente patrón para eliminar duplicados de un objeto del tipo C++ std::vector:duplicados eliminar de un QList
std::vector<int> cont;
std::sort(cont.begin(), cont.end());
cont.erase(std::unique(cont.begin(), cont.end()), cont.end());
Ahora estoy preguntando si el mismo paradigma es la de ser utilizado con la clase Qt QList<>, o si hay una forma más elegante de hacerlo.
No sé sobre el rendimiento, pero ¿qué hay de convertir el QList en un QSet?
QList<int> myQList;
//...
QSet<int> = QSet::fromList(myQList);
// or
QSet<int> = myQList.toSet();
(y tal vez volver a convertirlo en un QList si es necesario con QList::fromSet())
Eso es una manera, seguro, pero luego usaría QSet <> directamente.Por lo general, prefiero los contenedores secuenciales (que en la mayoría de los casos son la opción más adecuada), por lo que QSet <> o std :: set pueden considerarse exagerados. –
Supongo que es una cuestión de gusto: si necesito almacenar una lista de elementos sin duplicados, siempre elijo un conjunto. Sin embargo, nunca comparé el rendimiento. –
Bueno, solía usar 'std :: set' o' std :: map' mucho, hasta que tuve que luchar con problemas de rendimiento. Ahora lo pienso dos veces antes de ir por ese camino ;-). –
Si va a crear esta lista:
Entonces duplicados evitando puede ser una alternativa viable para la eliminación de duplicados.
QList<int> cont;
int incomingValue;
if(!cont.contains(incomingValue))
{
cont.append(incomingValue);
}
Además, dado que se trata de una pregunta sobre QList <> (y no sólo QList < int>) ...
Algunos pueden estar utilizando una clase personalizada, y como para evitar duplicados.
class SoftDrink
{
public:
int oz
QString flavor
bool operator==(const Beverage &other) const{
uint hash = qHash(flavor)^oz;
uint otherHash = qHash(other.flavor)^other.oz;
return hash == otherHash;
}
}
un operador == como la de arriba puede permitir QList para evaluar el método contains() en contra de un tipo de datos personalizada
QList<SoftDrink> uniquePurchaseHistory;
SoftDrink newPurchase;
if(!uniquePurchaseHistory.contains(newPurchase)){
uniquePurchaseHistory.append(newPurchase);
}
Sin Garantía:
Con QVector que parece trabajo ...
QVector<int> v;
std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end());//remove duplicates
A partir de Vector hacia atrás t o list:
Como se trata de listas, quiero señalar que std :: list tiene una función de clasificación de miembros que tiene un mejor rendimiento que std :: sort en una lista. –
y sí, recién redescubierto, std :: list también tiene la función de miembro 'único', lo que significa que es preferible a través de std :: unique. –
Gracias Amit por señalar esto, pero no uso std :: list <> mucho (siguiendo el consejo de Herb Sutter de que std :: vector es en la mayoría de los casos el contenedor "correcto" para usar, incluso en el estándar C++ existe tal una recomendación, ver 23.1.1/2). –