Copies the elements from the sorted range[first1, last1) which are not found in the sorted range[first2, last2) to the range beginning atd_first. The output range is also sorted.

If[first1, last1) containsm elements that are equivalent to each other and[first2, last2) containsn elements that are equivalent to them, the finalstd::max(m- n,0) elements will be copied from[first1, last1) to the output range, preserving order.

If the output range overlaps with[first1, last1) or[first2, last2), the behavior is undefined.

[edit]Parameters

[edit]Return value

Iterator past the end of the constructed range.

[edit]Complexity

Given\(\scriptsize N_1\)N1 asstd::distance(first1, last1) and\(\scriptsize N_2\)N2 asstd::distance(first2, last2):

[edit]Exceptions

The overloads with a template parameter namedExecutionPolicy report errors as follows:

• If execution of a function invoked as part of the algorithm throws an exception andExecutionPolicy is one of thestandard policies,std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined.
• If the algorithm fails to allocate memory,std::bad_alloc is thrown.

[edit]Possible implementation

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)returnstd::copy(first1, last1, d_first); if(*first1<*first2)*d_first++=*first1++;else{if(!(*first2<*first1))++first1;++first2;}}return d_first;}

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)returnstd::copy(first1, last1, d_first); if(comp(*first1,*first2))*d_first++=*first1++;else{if(!comp(*first2,*first1))++first1;++first2;}}return d_first;}

[edit]Example

#include <algorithm>#include <iostream>#include <iterator>#include <vector> template<typename T>std::ostream& operator<<(std::ostream& os,conststd::vector<T>& v){    os<<'{';for(auto n{v.size()};constauto& e: v)        os<< e<<(--n?", ":"");return os<<'}';} struct Order// a struct with very interesting data{int order_id{}; friendstd::ostream& operator<<(std::ostream& os,const Order& ord){return os<< ord.order_id;}}; int main(){conststd::vector<int> v1{1,2,5,5,5,9};conststd::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';}

{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}

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]See also

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文