Warum kann nicht std :: is_permutation zwischen zwei verschiedenen Arten von Daten handeln?

Question

Angenommen, ich habe einen Vektor von ganzen Zahlen und von Strings, und ich möchte vergleichen, ob sie äquivalente Elemente haben, ohne Berücksichtigung der Reihenfolge. Letztendlich frage ich, ob der Integer-Vektor eine Permutation des String-Vektors ist (oder umgekehrt). Ich möchte in der Lage sein, einfach is_permutation aufzurufen, ein binäres Prädikat anzugeben, das es mir erlaubt, die beiden zu vergleichen, und mit meinem Leben weiterzumachen. zB:

bool checkIntStringComparison(const std::vector<int>& intVec, 
       const std::vector<std::string>& stringVec, 
       const std::map<int, std::string>& intStringMap){ 
    return std::is_permutation<std::vector<int>::const_iterator, std::vector<std::string>::const_iterator>(
     intVec.cbegin(), intVec.cend(), stringVec.cbegin(), [&intStringMap](const int& i, const std::string& string){ 
    return string == intStringMap.at(i); 
    }); 
} 

Aber versuchen, dies zu kompilieren (in gcc) gibt eine Fehlermeldung, läuft darauf hinaus: für Call

keine Übereinstimmung zu Sachen :: < Lambda (const int &, const string &>) (const std :: _ cxx11 :: basic_string &, const int &)

siehe h Wodurch schaltet er die rufende Signatur von den Lambda's? Wenn ich sie umschalte, schaltet sich die Signatur in die andere Richtung um.

Um diesen Fehler zu umgehen scheint es, dass der Standard für std :: is_permutation angibt, dass ForwardIterator1 und 2 vom gleichen Typ sein müssen. Also verstehe ich den Compiler Fehler in dieser Hinsicht. Aber warum sollte es so sein? Wenn ich ein binäres Prädikat zur Verfügung stelle, das es mir erlaubt, die beiden zu vergleichen (oder wenn wir zuvor einen Gleichheitsoperator zwischen den beiden definiert haben?), Ist der eigentliche Kern des Algorithmus nicht nur die Suche in Container 1, um sicherzustellen, dass alle seine Elemente sind in Behälter 2 einzigartig?

Answer 1

Das Problem ist, dass ein Element mehr als einmal auftreten kann. Das bedeutet, dass das Prädikat in der Lage sein muss, um nicht nur die Elemente des ersten Bereichs auf die Elemente des zweiten Bereichs zu vergleichen, aber die Elemente des ersten Bereichs, um sich zu vergleichen:

if (size(range1) != size(range2)) 
    return false; 
for (auto const& x1 : range1) 
    if (count_if(range1, [&](auto const& y1) { return pred(x1, y1); }) != 
     count_if(range2, [&](auto const& y2) { return pred(x1, y2); })) 
     return false; 
return true; 

Da es relativ heikel ist Um ein Funktionsobjekt zu erstellen, das zwei unterschiedliche Signaturen akzeptiert, und zwei Prädikate zu übergeben, wäre verwirrend. Die einfachste Option bestand darin, anzugeben, dass beide Bereiche denselben Werttyp haben müssen.

Ihre Optionen sind:

• Wrap eine Reihe (oder beides) in einer Transformation, die den gleichen Wert Typen (zum Beispiel verwenden Boost.Adaptors.Transformed) gibt;
• Schreiben Sie Ihre eigene Implementierung von std :: is_permutation (z. B. Kopieren der Beispielimplementierung in cppreference);
• Beachten Sie, dass die Implementierung von gcc (d. H. LibstdC++) nicht erzwingt, dass die Werttypen identisch sind; es erfordert nur einige Signaturen, die Sie sowieso bereitstellen müssten, also schreiben Sie ein polymorphes Prädikat wie z. ein Funktionsobjekt oder ein polymorphes Lambda oder mit Parametertypen, die aus beiden Bereichswerttypen konvertierbar sind (z. B. in Ihrem Fall boost::variant<int, string> - hässlich, aber wahrscheinlich nicht so schlimm). Dies ist nicht portierbar, da eine andere Implementierung diese Anforderung möglicherweise erzwingen kann.