C++ Algorithm set_symmetric_difference()

C++ Algorithm set_symmetric_difference() function is used to find the symmetric difference between two sorted ranges[first1, last1) and [first2, last2), which is formed by the elements and is present in one of the range, but not in the other.

Elements are compared using operator < for the first version or using the given binary comparison function comp for the second version.

Syntax

default (1)    template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1,
      InputIterator2 first2, InputIterator2 last2, OutputIterator result);

custom (2)    template <class InputIterator1, class InputIterator2,
          class OutputIterator, class Compare>
  OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1,
       InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);

Parameter

first1: An input iterator pointing to the first element in the first of two sorted source sequences.

last1: An input iterator pointing to the past last element in the first of two sorted source sequences.

first2: An input iterator pointing to the first element in the second sorted source sequence.

last2: An input iterator pointing to the past last element in the second sorted source sequence.

comp: A user-defined binary predicate function that accepts two arguments and returns true if the two arguments are in order otherwise returns false. It follows the strict weak ordering to order the elements.

result: An output iterator addressing to the position of the first element in the destination range.

Return value

This function returns an iterator to the end of the constructed range.

Complexity

Complexity is linear in the distance between [first1, last1) and [first2, last2): performs up to 2*(count1+count2)-1 comparisons. Where count1 = last1- first1 and count2 = last2- first2.

Data races

The object in the range [first1, last1) and [first2. last2) are accessed.

The object in the range between result and returned value are modified.

Exceptions

This function throws an exception if any of element comparisons, the element assignments or an operation on iterator throws an exception.

Please note that invalid parameters cause an undefined behavior.

Example 1

Let's see a simple example:

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

using namespace std;

int main()
{
  list<int> a = {1, 2, 3, 4, 5, 8};
  multiset<int> b = {2, 3, 4, 7};
  vector<int> result;

  set_symmetric_difference(begin(a), end(a),
                 begin(b), end(b),
                 inserter(result, end(result)));

  for_each(begin(result), end(result), [](int x) {
    cout << x << endl;
  });
  
  return 0;
}

Output:

Example 2

Let's see another simple example:

#include <iostream>     // std::cout
#include <algorithm>    // std::set_union, std::sort
#include <vector>       // std::vector

using namespace std;

int main() 
{ 
    int first[] = { 5, 10, 15, 20, 25 }; 
    int second[] = { 50, 40, 30, 20, 10 }; 
    int n = sizeof(first) / sizeof(first[0]); 
  
    // Print first array 
    cout << "First array contains :"; 
    for (int i = 0; i < n; i++) 
        cout << " " << first[i]; 
    cout << "\n"; 
  
    // Print second array 
    cout << "Second array contains :"; 
    for (int i = 0; i < n; i++) 
        cout << " " << second[i]; 
    cout << "\n\n"; 
  
    vector<int> v(10); 
    vector<int>::iterator it, st; 
  
    sort(first, first + n); 
    sort(second, second + n); 
  
    // Using default function 
    it = set_symmetric_difference(first, first + n, second, second + n, v.begin()); 
  
    cout << "The difference has " << (it - v.begin()) << " elements:\n"; 
    for (st = v.begin(); st != it; ++st) 
        cout << ' ' << *st; 
    cout << '\n'; 
  
    return 0; 
}

Output:

First array contains : 5 10 15 20 25
Second array contains : 50 40 30 20 10

The difference has 6 elements:
 5 15 25 30 40 50

Example 3

Let's see another simple example to find the students that are not taking both classes:

#include <iostream>     // std::cout
#include <algorithm>    // std::set_union, std::sort
#include <vector>       // std::vector

using namespace std; 
  
int main() 
{   
    // students attending first class 
    std::vector<string> class1{ "Nikita", "Deep", "Aman", "Divya" }; 
  
    // students attending second class 
    std::vector<string> class2{ "Nikita", "Amita", "Deep", "Priya", "Kashish" }; 
  
    cout << "Students attending first class are : "; 
    for (auto i : class1) { 
        cout << i << " "; 
    } 
    cout << "\nStudents attending second class are : "; 
    for (auto i : class2) { 
        cout << i << " "; 
    } 
  
    // to store the result of symmetric difference 
    std::vector<string> result(10); 
  
    std::vector<string>::iterator it; 
  
    // finding symmetric difference 
    it = set_symmetric_difference(class1.begin(), 
                                  class1.end(), class2.begin(), class2.end(), result.begin()); 
  
    cout << "\n\nList of students that are not taking both classes :"; 
  
    for (std::vector<string>::iterator i = result.begin(); i != it; i++) { 
        cout << *i << " "; 
    } 
    return 0; 
} 

Output:

Students attending first class are : Nikita Deep Aman Divya 
Students attending second class are : Nikita Amita Deep Priya Kashish 

List of students that are not taking both classes :Amita Aman Divya Priya Kashish

Example 4

Let's see another simple example:

#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>

using namespace std;
 
int main()
{ 
    vector<char> v1 = {'A', 'B', 'C'}; 
    vector<char> v2 = { 'B', 'C', 'D', 'E', 'F'}; 
    
    vector<char> dest1;
 
    set_symmetric_difference(v1.begin(), v1.end(),
                   v2.begin(), v2.end(),                  
                   back_inserter(dest1));
 
    for (const auto &i : dest1) {
        cout << i << ' ';
    }   
    cout << '\n';
    
    return 0;
}

Output: