std::set_difference
| Definiert in Header <algorithm> |
||
template< class InputIt1, class InputIt2, class OutputIt > OutputIt set_difference( InputIt1 first1, InputIt1 last1, |
(1) | (constexpr seit C++20) |
| template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class ForwardIt3 > |
(2) | (seit C++17) |
template< class InputIt1, class InputIt2, class OutputIt, class Compare > |
(3) | (constexpr seit C++20) |
| template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, |
(4) | (seit C++17) |
Kopiert die Elemente aus dem sortierten Bereich [first1, last1), die nicht im sortierten Bereich [first2, last2) gefunden werden, in den Bereich, der bei d_first beginnt. Der Ausgabebereich ist ebenfalls sortiert.
Wenn [first1, last1) m Elemente enthält, die zueinander äquivalent sind, und [first2, last2) n Elemente enthält, die zu ihnen äquivalent sind, werden die letzten std::max(m - n, 0) Elemente aus [first1, last1) in den Ausgabebereich kopiert, wobei die Reihenfolge beibehalten wird.
[first1, last1) oder [first2, last2) nicht sortiert ist in Bezug auf operator<(bis C++20)std::less{}(seit C++20), ist das Verhalten undefiniert.[first1, last1) oder [first2, last2) nicht sortiert ist bezüglich comp, ist das Verhalten undefiniert.|
std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> ist true. |
(bis C++20) |
|
std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> ist true. |
(seit C++20) |
Wenn sich der Ausgabebereich mit [first1, last1) oder [first2, last2) überschneidet, ist das Verhalten undefiniert.
Inhalt |
[bearbeiten] Parameter
| first1, last1 | - | das Paar von Iteratoren, das den ersten Eingabesortierten Bereich von zu prüfenden Elementen definiert |
| first2, last2 | - | das Paar von Iteratoren, das den zweiten Eingabesortierten Bereich von zu suchenden Elementen definiert |
| d_first | - | der Anfang des Ausgabebereichs |
| policy | - | die Ausführungsrichtlinie, die verwendet werden soll |
| comp | - | Vergleichsfunktions-Objekt (d.h. ein Objekt, das die Anforderungen an Compare erfüllt), das true zurückgibt, wenn das erste Argument *weniger* (d.h. *vorher*) als das zweite geordnet ist. Die Signatur der Vergleichsfunktion sollte äquivalent zu Folgendem sein bool cmp(const Type1& a, const Type2& b); Obwohl die Signatur nicht unbedingt const& haben muss, darf die Funktion die übergebenen Objekte nicht verändern und muss in der Lage sein, alle Werte vom Typ (möglicherweise const) |
| Typanforderungen | ||
-InputIt1, InputIt2 müssen die Anforderungen an LegacyInputIterator erfüllen. | ||
-OutputIt muss die Anforderungen an LegacyOutputIterator erfüllen. | ||
-ForwardIt1, ForwardIt2, ForwardIt3 müssen die Anforderungen von LegacyForwardIterator erfüllen. | ||
-Compare muss die Anforderungen an Compare erfüllen. | ||
[bearbeiten] Rückgabewert
Iterator hinter das Ende des erstellten Bereichs.
[bearbeiten] Komplexität
Gegeben N1 als std::distance(first1, last1) und N2 als std::distance(first2, last2)
[bearbeiten] Ausnahmen
Die Überladungen mit einem Template-Parameter namens ExecutionPolicy berichten Fehler wie folgt
- Wenn die Ausführung einer Funktion, die als Teil des Algorithmus aufgerufen wird, eine Ausnahme auslöst und
ExecutionPolicyeine der Standardrichtlinien ist, wird std::terminate aufgerufen. Für jede andereExecutionPolicyist das Verhalten implementierungsabhängig. - Wenn dem Algorithmus der Speicher zur Neuzuweisung fehlt, wird std::bad_alloc ausgelöst.
[bearbeiten] Mögliche Implementierung
| set_difference (1) |
|---|
template<class InputIt1, class InputIt2, class OutputIt> OutputIt set_difference(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first) { while (first1 != last1) { if (first2 == last2) return std::copy(first1, last1, d_first); if (*first1 < *first2) *d_first++ = *first1++; else { if (! (*first2 < *first1)) ++first1; ++first2; } } return d_first; } |
| set_difference (3) |
template<class InputIt1, class InputIt2, class OutputIt, class Compare> OutputIt set_difference(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first, Compare comp) { while (first1 != last1) { if (first2 == last2) return std::copy(first1, last1, d_first); if (comp(*first1, *first2)) *d_first++ = *first1++; else { if (!comp(*first2, *first1)) ++first1; ++first2; } } return d_first; } |
[bearbeiten] Beispiel
#include <algorithm> #include <iostream> #include <iterator> #include <vector> template<typename T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) { os << '{'; for (auto n{v.size()}; const auto& e : v) os << e << (--n ? ", " : ""); return os << '}'; } struct Order // a struct with very interesting data { int order_id{}; friend std::ostream& operator<<(std::ostream& os, const Order& ord) { return os << ord.order_id; } }; int main() { const std::vector<int> v1{1, 2, 5, 5, 5, 9}; const std::vector<int> v2{2, 5, 7}; std::vector<int> diff; std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), std::inserter(diff, diff.begin())); std::cout << v1 << " ∖ " << v2 << " == " << diff << "\n\n"; // we want to know which orders "cut" between old and new states: std::vector<Order> old_orders{{1}, {2}, {5}, {9}}; std::vector<Order> new_orders{{2}, {5}, {7}}; std::vector<Order> cut_orders; std::set_difference(old_orders.begin(), old_orders.end(), new_orders.begin(), new_orders.end(), std::back_inserter(cut_orders), [](auto& a, auto& b) { return a.order_id < b.order_id; }); std::cout << "old orders: " << old_orders << '\n' << "new orders: " << new_orders << '\n' << "cut orders: " << cut_orders << '\n'; }
Ausgabe
{1, 2, 5, 5, 5, 9} ∖ {2, 5, 7} == {1, 5, 5, 9}
old orders: {1, 2, 5, 9}
new orders: {2, 5, 7}
cut orders: {1, 9}[bearbeiten] Fehlerberichte
Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | angewendet auf | Verhalten wie veröffentlicht | Korrigiertes Verhalten |
|---|---|---|---|
| LWG 291 | C++98 | es war nicht spezifiziert, wie äquivalente Elemente in den Eingabebereichen behandelt werden sollen | spezifiziert |
[bearbeiten] Siehe auch
| Gibt true zurück, wenn eine Sequenz eine Untersequenz einer anderen ist (Funktionstemplate) | |
| Berechnet die symmetrische Differenz zwischen zwei Mengen (Funktionstemplate) | |
| (C++20) |
Berechnet die Differenz zwischen zwei Mengen (Algorithmus-Funktionsobjekt) |
