std::set_symmetric_difference
| Definiert in Header <algorithm> |
||
template< class InputIt1, class InputIt2, class OutputIt > OutputIt set_symmetric_difference |
(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) |
Berechnet die symmetrische Differenz von zwei sortierten Bereichen: die Elemente, die in einem der Bereiche vorkommen, aber nicht in beiden, werden in den Bereich kopiert, 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, dann werden std::abs(m - n) dieser Elemente in den Ausgabebereich kopiert, wobei die Reihenfolge beibehalten wird.
- wenn m > n, die letzten m - n dieser Elemente aus
[first1,last1). - wenn m < n, die letzten n - m dieser Elemente aus
[first2,last2).
[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 Iteratorenpaar, das den ersten sortierten Bereich der Elemente definiert |
| first2, last2 | - | das Iteratorenpaar, das den zweiten sortierten Bereich der Elemente 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_symmetric_difference (1) |
|---|
template<class InputIt1, class InputIt2, class OutputIt> OutputIt set_symmetric_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) *d_first++ = *first2; else ++first1; ++first2; } } return std::copy(first2, last2, d_first); } |
| set_symmetric_difference (3) |
template<class InputIt1, class InputIt2, class OutputIt, class Compare> OutputIt set_symmetric_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)) *d_first++ = *first2; else ++first1; ++first2; } } return std::copy(first2, last2, d_first); } |
[bearbeiten] Beispiel
#include <algorithm> #include <iostream> #include <iterator> #include <vector> int main() { std::vector<int> v1{1, 2, 3, 4, 5, 6, 7, 8}; std::vector<int> v2{5, 7, 9, 10}; std::sort(v1.begin(), v1.end()); std::sort(v2.begin(), v2.end()); std::vector<int> v_symDifference; std::set_symmetric_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(v_symDifference)); for (int n : v_symDifference) std::cout << n << ' '; std::cout << '\n'; }
Ausgabe
1 2 3 4 6 8 9 10
[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 Differenz zwischen zwei Mengen (Funktionstemplate) | |
| Berechnet die Vereinigung zweier Mengen (Funktionstemplate) | |
| Berechnet den Schnitt zweier Mengen (Funktionstemplate) | |
| Berechnet die symmetrische Differenz zwischen zwei Mengen (Algorithmus-Funktionsobjekt) |
