c++ - Entfernen Sie doppelte Objekt aus QList

5

std::list::unique kann als argument eine Funktion mit den folgenden Eigenschaften:

Binäre Prädikat,, dass zwei Werte vom gleichen Typ als die
in der Liste enthalten, true zurück, entfernen Sie das element übergeben
erstes argument aus dem container, und andernfalls false.
Dies soll ein Funktionszeiger oder ein function-Objekt.

Also in Ihrem Fall könnten Sie die folgende Funktion:
```
bool shouldRemove(MyData first, MyData second)
{
    //remove only if they have the same name and the first id
    //is smaller than the second one 
    return ( first.name == second.name && 
             first.id <= second.id ); 
}
```
Nenne es einfach tun,
```
std::list<MyData> myList = qlist.toStdList();
myList.unique(shouldRemove)
```
Beachten Sie, dass Sie benötigen, um zu Sortieren zuerst die std::list

Bearbeiten

Es scheint, dass Sie verwenden können std::unique mit Qt containers (wenn Qt ist gebaut mit STL-support). So auch in diesem Fall können Sie Folgendes tun:
```
//lessThan is a function that sorts first by name and then by id
qSort(qList.begin(), qList.end(), lessThan );
QList<MyData>::iterator it = std::unique (qList.begin(), qList.end(), shouldRemove);
qList.erase(it, qList.end());
```
- danke, das funktioniert am besten für mich 😀
InformationsquelleAutor pnezis
2

Wie wäre es damit:
```
QList<MyData> theList = ...;

QHash<QString, int> nameToIdMap;

for (const MyData& element : theList) {

    auto iter = nameToIdMap.find(element.name);
    if (iter != nameToIdMap.end() && iter.second > element.id) {
        //If item exists in map (name already occured) and the ID is 
        //bigger than in the current element, just skip the current element.
        continue;
    }

    //Otherwise, insert/overwrite it in the map.
    nameToIdMap[element.name] = element.id;
});

//nameToIdMap should now map unique names to highest IDs. If desired,
//you could copy it back into a new list by iterating over the map's entries
//and creating new MyData elements accordingly.
```
Der Vorteil dieser, in meinen Augen: Sie müssen nicht konvertieren Sie die Liste in eine std-container und zurück, und wenn Sie einen Weg finden, weiter zu arbeiten mit der QMap statt einer QList, haben Sie nur zu iterieren, einmal über die Liste. Und QHash geben Sie abgeschrieben O(1) lookup Komplexität.

Edit: Geändert QHash.
- Das ist eine schöne Idee auch, aber ich habe 1 wichtigen Punkt meiner Frage: ich habe eigentlich mehr als 2 Mitglieder in MyData. Meine schlechten 🙁
- Das ist nicht viel von einem problem: nutzen Sie Einfach die QHash<QString, MyData>, und ändern Sie dann die if-Anweisung ist die zweite Bedingung: iter.second.id > element.id. Oder vielleicht MyData* in die QHash, um zu vermeiden, kopieren Sie alle MyDatas.
- +1: cool für die syntax! Ich habe zum Wechsel auf den neuen standard so schnell wie möglich 🙂
InformationsquelleAutor lethal-guitar

Ich Tat dies, indem STL-Container, aber ich denke, es ist nicht sehr schwer zu konvertieren, es zu Qt-Container

gehören

#include <list>
#include <set>
#include <iostream>
#include <algorithm>

struct MyData {
    int id;
    std::string name;
};

struct MyDataSortComparator {
    bool operator()( const MyData & left, const MyData & right ) {
        if ( left.name < right.name ) {
            return true;
        }
        else if ( left.name > right.name ) {
            return false;
        }
        return left.id > right.id;
    }
};

struct MyDataSetComparator {
    bool operator()( const MyData & left, const MyData & right ) {
        return left.name < right.name;
    }
};


int main() {
    std::list< MyData > theList = {
        { 1, "Dickson" },
        { 2, "Dickson" },
        { 3, "Dickson" },
        { 2, "borisbn" },
        { 1, "borisbn" }
    };
    std::set< MyData, MyDataSetComparator > theSet;
    theList.sort( MyDataSortComparator() );
    std::for_each( theList.begin(), theList.end(), []( const MyData & data ) {
        std::cout << data.id << ", " << data.name << std::endl;
    } );
    std::for_each( theList.begin(), theList.end(), [&theSet]( const MyData & data ) {
        theSet.insert( data );
    } );
    std::cout << "-------------------" << std::endl;
    std::for_each( theSet.begin(), theSet.end(), []( const MyData & data ) {
        std::cout << data.id << ", " << data.name << std::endl;
    } );
}

http://liveworkspace.org/code/wOFnM$5

Sie sind bereits mit lambdas - warum nicht für die Sortier-und set-Vergleich?
Ich weiß nicht, wie lange-Länge Lambda-Ausdrücke, das ist, warum ich nicht verwenden Sie es in Art. In der anderen hand ich weiß nicht, wie zu verwenden, lambda -, in-set-definition. Könnten Sie mir sagen, wie erklären theSet in meinem Beispiel von der lambda ? Dank
Ok, anscheinend ist es nicht möglich, in die definition.. schade, ich mag mit lambdas für alles..

InformationsquelleAutor borisbn

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.