blocks|key|2063150|text|是的，在算法头中有一个set_difference函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2063151|编辑：|style|BOLD|2063152|仅供参考，set数据结构能够有效地使用该算法，如其documentation中所述。该算法不仅适用于集合，还适用于排序集合上的任何一对迭代器。|2063153|正如其他人所提到的，这是一种外部算法，而不是一种方法。想必这对您的应用程序来说是很好的。|2063154|entityMap|0|LINK|mutability|MUTABLE|url|http://www.sgi.com/tech/stl/set_difference.html|1|http://www.sgi.com/tech/stl/set.html^0|B|E|0|0|0|3|0|P|D|1|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|6|7|Z|8|@$A|10|B|11|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]|T|$5|O|P|Q|C|$R|U]]]]

Yes, there is a <a href="http://www.sgi.com/tech/stl/set_difference.html" rel="noreferrer">set_difference</a> function in the algorithms header.

Edits:

FYI, the set data structure is able to efficiently use that algorithm, as stated in its <a href="http://www.sgi.com/tech/stl/set.html" rel="noreferrer">documentation</a>. The algorithm also works not just on sets but on any pair of iterators over sorted collections.

As others have mentioned, this is an external algorithm, not a method. Presumably that's fine for your application.

blocks|key|5591014|text|不是作为一种方法，而是有外部算法函数set_difference|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5591015|template+<class+InputIterator1,+class+InputIterator2,+class+OutputIterator>
OutputIterator+set_difference(InputIterator1+first1,+InputIterator1+last1,
++++++++++++++++++++++++++++++InputIterator2+first2,+InputIterator2+last2,
++++++++++++++++++++++++++++++OutputIterator+result);|code-block|syntax|javascript|5591016|http://www.sgi.com/tech/stl/set_difference.html|offset|length|5591017|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|1B|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

Not as a method but there's the external algorithm function set_difference

<pre><code>template &lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
 InputIterator2 first2, InputIterator2 last2,
 OutputIterator result);
</code></pre>

<a href="http://www.sgi.com/tech/stl/set_difference.html" rel="nofollow noreferrer">http://www.sgi.com/tech/stl/set_difference.html</a>

blocks|key|2063193|text|显然，确实如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2063194|SGI+-+set_difference|offset|length|2063195|entityMap|0|LINK|mutability|MUTABLE|url|http://www.sgi.com/tech/stl/set_difference.html^0|0|0|K|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Apparently, it does.

<a href="http://www.sgi.com/tech/stl/set_difference.html" rel="nofollow noreferrer">SGI - set_difference</a>

blocks|key|2063242|text|不是语言意义上的“运算符”，但在标准库中有set_difference算法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2063243|http://www.cplusplus.com/reference/algorithm/set_difference.html|offset|length|2063244|当然，其他基本的集合操作也存在-(联合等)，正如链接文章末尾的“另请参阅”部分所建议的那样。|2063245|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1S|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

Not an "operator" in the language sense, but there is the set_difference algorithm in the standard library:

<a href="http://www.cplusplus.com/reference/algorithm/set_difference.html" rel="nofollow noreferrer">http://www.cplusplus.com/reference/algorithm/set_difference.html</a>

Of course, the other basic set operations are present too - (union etc), as suggested by the "See also" section at the end of the linked article.

blocks|key|4173550|text|是的，有，它在<algorithm>中，叫做：std::set_difference。其用法为：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4173551|#include+<algorithm>
#include+<set>
#include+<iterator>
//+...
std::set<int>+s1,+s2;
//+Fill+in+s1+and+s2+with+values
std::set<int>+result;
std::set_difference(s1.begin(),+s1.end(),+s2.begin(),+s2.end(),
++++std::inserter(result,+result.end()));|code-block|syntax|javascript|4173552|最后，集合result将包含s1-s2。|4173553|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/algorithm/set_difference^0|7|B|N|J|N|J|0|0|0|5|6|E|5|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

Yes there is, it is in <code>&lt;algorithm&gt;</code> and is called: <a href="http://en.cppreference.com/w/cpp/algorithm/set_difference" rel="noreferrer"><code>std::set_difference</code></a>. The usage is:

<pre><code>#include &lt;algorithm&gt;
#include &lt;set&gt;
#include &lt;iterator&gt;
// ...
std::set&lt;int&gt; s1, s2;
// Fill in s1 and s2 with values
std::set&lt;int&gt; result;
std::set_difference(s1.begin(), s1.end(), s2.begin(), s2.end(),
 std::inserter(result, result.end()));
</code></pre>

In the end, the set <code>result</code> will contain the <code>s1-s2</code>.

blocks|key|5591170|text|选择的答案是正确的，但有一些语法错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5591171|而不是|5591172|#include+<algorithms>|code-block|syntax|javascript|5591173|使用|5591174|#include+<algorithm>|5591175|5591176|std::insert_iterator(result,+result.end()));|5591177|5591178|std::insert_iterator<set<int>+>(result,+result.end()));|5591179|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|P|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|S|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|T|$]]

The chosen answer is correct, but has some syntax errors.

Instead of 

<pre><code>#include &lt;algorithms&gt;
</code></pre>

use

<pre><code>#include &lt;algorithm&gt;
</code></pre>

Instead of

<pre><code>std::insert_iterator(result, result.end()));
</code></pre>

use

<pre><code>std::insert_iterator&lt;set&lt;int&gt; &gt;(result, result.end()));
</code></pre>

blocks|key|1648765|text|我们能不能只用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1648766|+set_difference(set1.begin(),+set1.end(),+set2.begin().+set2,end(),std::back_inserter(result)).|code-block|syntax|javascript|1648767|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

can we just use

<pre><code> set_difference(set1.begin(), set1.end(), set2.begin(). set2,end(),std::back_inserter(result)).
</code></pre>

blocks|key|5591237|text|再一次，助力拯救：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5591238|#include+<string>
#include+<set>
#include+<boost/range/algorithm/set_algorithm.hpp>

std::set<std::string>+set0,+set1,+setDifference;
boost::set_difference(set0,+set1,+std::inserter(setDifference,+setDifference.begin());|code-block|syntax|javascript|5591239|setDifference将包含set0-set1。|5591240|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Once again, boost to the rescue:

<pre><code>#include &lt;string&gt;
#include &lt;set&gt;
#include &lt;boost/range/algorithm/set_algorithm.hpp&gt;

std::set&lt;std::string&gt; set0, set1, setDifference;
boost::set_difference(set0, set1, std::inserter(setDifference, setDifference.begin());
</code></pre>

setDifference will contain set0-set1.

blocks|key|5591268|text|C%2B%2B没有定义set+difference运算符，但您可以定义自己的运算符(使用其他响应中提供的代码)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5591269|template<class+T>
set<T>+operator+-(set<T>+reference,+set<T>+items_to_remove)
{
++++set<T>+result;
++++std::set_difference(
++++++++reference.begin(),+reference.end(),
++++++++items_to_remove.begin(),+items_to_remove.end(),
++++++++std::inserter(result,+result.end()));
++++return+result;
}|code-block|syntax|javascript|5591270|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

C++ does not define a set difference operator but you can define your own (using code given in other responses):

<pre><code>template&lt;class T&gt;
set&lt;T&gt; operator -(set&lt;T&gt; reference, set&lt;T&gt; items_to_remove)
{
 set&lt;T&gt; result;
 std::set_difference(
 reference.begin(), reference.end(),
 items_to_remove.begin(), items_to_remove.end(),
 std::inserter(result, result.end()));
 return result;
}
</code></pre>

blocks|key|1652000|text|我在这里看到的所有答案都是O(n)。这样不是更好吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1652001|template+<class+Key,+class+Compare,+class+Allocator>+++
std::set<Key,+Compare,+Allocator>+
set_subtract(std::set<Key,+Compare,+Allocator>&&+lhs,
+++++++++++++const+std::set<Key,+Compare,+Allocator>&+rhs)+{
++++if+(lhs.empty())+{+return+lhs;+}
++++//+First+narrow+down+the+overlapping+range:
++++const+auto+rhsbeg+=+rhs.lower_bound(*lhs.begin());
++++const+auto+rhsend+=+rhs.upper_bound(*lhs.rbegin());
++++for+(auto+i+=+rhsbeg;+i+!=+rhsend;+%2B%2Bi)+{
++++++++lhs.erase(*i);
++++}
++++return+std::move(lhs);
}|code-block|syntax|javascript|1652002|这似乎是正确的做法。我不确定如何处理Compare的类型没有完全指定其行为的情况，比如Compare是一个std::function<bool(int,int)>，但除此之外，这似乎是正确的，应该类似于O((num重叠)·log(lhs.size()))。|offset|length|style|CODE|1652003|在lhs不包含对数的情况下，可以通过O(+*i+(rhs.size()))搜索rhs的下一个元素>=+lhs的下一个元素来进一步优化。这将优化lhs+=+{0,+1000}和rhs+=+{1,+2,+...,+999}在对数时间内进行减法的情况。|1652004|entityMap^0|0|0|I|7|17|7|1H|S|37|A|0|1|3|L|2|P|A|13|3|1F|3|1Z|F|2F|M|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@$I|12|J|13|K|L]|$I|14|J|15|K|L]|$I|16|J|17|K|L]|$I|18|J|19|K|L]|$I|1A|J|1B|K|L]|$I|1C|J|1D|K|L]|$I|1E|J|1F|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|P|$]]

All of the answers I see here are O(n). Wouldn't this be better?:

<pre class="lang-cpp prettyprint-override"><code>template &lt;class Key, class Compare, class Allocator&gt; 
std::set&lt;Key, Compare, Allocator&gt; 
set_subtract(std::set&lt;Key, Compare, Allocator&gt;&amp;&amp; lhs,
 const std::set&lt;Key, Compare, Allocator&gt;&amp; rhs) {
 if (lhs.empty()) { return lhs; }
 // First narrow down the overlapping range:
 const auto rhsbeg = rhs.lower_bound(*lhs.begin());
 const auto rhsend = rhs.upper_bound(*lhs.rbegin());
 for (auto i = rhsbeg; i != rhsend; ++i) {
 lhs.erase(*i);
 }
 return std::move(lhs);
}
</code></pre>

That seems to do the right thing. I'm not sure how to deal with the case that <code>Compare</code>'s type doesn't fully specify its behavior, as in if <code>Compare</code> is a <code>std::function&lt;bool(int,int)&gt;</code>, but aside from that, this seems to work right and should be like O((num overlapping) • log(<code>lhs.size()</code>)).

In the case that <code>lhs</code> doesn't contain <code>*i</code>, it's probably possible to optimize further by doing an O(log(<code>rhs.size()</code>)) search for the next element of <code>rhs</code> that's >= the next element of <code>lhs</code>. That would optimize the case that <code>lhs = {0, 1000}</code> and <code>rhs = {1, 2, ..., 999}</code> to do the subtraction in log time.

Does the C++ STL set data structure have a set difference operator?

c++ STL set difference

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

C++ STL集合数据结构是否有集合差运算符？

问c++ STL集合差异
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问c++ STL集合差异EN