blocks|key|3441486|text|关于第二个问题:适用于布尔表达式的标准C惰性计算规则。如果%7C%7C的LHS为真，则不计算RHS。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3441487|entityMap^0|T|2|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Regarding the second question: Standard C lazy evaluation rules for boolean expressions apply. If the LHS of <code>||</code> is true, the RHS is not evaluated.

blocks|key|952673|text|C%2B%2B使用%7C%7C从左到右计算if()。计算左边(lhs+<+rhs)+-如果它是真的并且它不是一个复合语句(它不在你的例子中)，它计算整个If为真而不检查右边。(然后确实返回取反的值，因为前面没有该值。)如果为false，则移动到右侧(rhs+<+lhs)并对其求值，然后计算整个表达式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|952674|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

C++ evaluates if() left to right for your case with ||. Evaluates left side (lhs &lt; rhs) - If it's true and it's not a compound statement (it's not in your case), it evaluates the whole if as true without checking the right side. (Then indeed returns negated value since there's not in front of it.) If it's false then it moves on to the right side (rhs &lt; lhs) and evaluates that and then the whole expression.

blocks|key|5054621|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5054622|+STL关联容器|blockquote|5054623|5054624|5054625|您的意思是:标准C%2B%2B排序关联容器。|5054626|我本以为|5054627|容器只需要一个额外的默认参数来表示相等。|5054628|5054629|5054630|那会有什么效果呢？在教科书中的红黑树算法中，而不是|5054631|if+(x+<+y)
++++//+...
else+if+(y+<+x)
++++//+...
else
++++//+equality|code-block|syntax|javascript|5054632|你就会有|5054633|if+(x+==+y)
++++//+equality
else+if+(x+<+y)
++++//+...
else
++++//+y+<+x|5054634|因此，在最坏的情况下，仍然有两个比较。|5054635|对此答案的回应是:只需提供一个小于运算符就可以使容器更易于使用，因为不需要维护小于和等于之间的一致性。假设你有一个存储浮点数的程序。有一天，有人决定通过近似比较来替换按位相等的float_equals函数，该函数恰好被一些容器使用，但也被它们的代码使用。如果这个人不更新float_less函数，因为他们的代码不使用该函数，那么您的容器代码就会神秘地崩溃。|offset|length|style|CODE|5054636|(哦，在所示的示例代码中，短路作用一如既往。)|5054637|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|2G|C|3R|A|0|0^^$0|@$1|2|3|-4|4|5|6|1A|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1B|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1D|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1E|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|1F|7|@]|8|@]|9|$]]|$1|J|3|K|4|C|6|1G|7|@]|8|@]|9|$]]|$1|L|3|-4|4|5|6|1H|7|@]|8|@]|9|$]]|$1|M|3|-4|4|5|6|1I|7|@]|8|@]|9|$]]|$1|N|3|O|4|5|6|1J|7|@]|8|@]|9|$]]|$1|P|3|Q|4|R|6|1K|7|@]|8|@]|9|$S|T]]|$1|U|3|V|4|5|6|1L|7|@]|8|@]|9|$]]|$1|W|3|X|4|R|6|1M|7|@]|8|@]|9|$S|T]]|$1|Y|3|Z|4|5|6|1N|7|@]|8|@]|9|$]]|$1|10|3|11|4|5|6|1O|7|@$12|1P|13|1Q|14|15]|$12|1R|13|1S|14|15]]|8|@]|9|$]]|$1|16|3|17|4|5|6|1T|7|@]|8|@]|9|$]]|$1|18|3|-4|4|5|6|1U|7|@]|8|@]|9|$]]]|19|$]]

<blockquote>
 STL associative containers
</blockquote>

You mean: standard C++ sorted associative containers.

<blockquote>
 I would have expected STL containers to just take an extra default parameter for equality instead.
</blockquote>

What would that achieve? In your textbook red-black tree algorithm, instead of

<pre><code>if (x &lt; y)
 // ...
else if (y &lt; x)
 // ...
else
 // equality
</code></pre>

you'd have

<pre><code>if (x == y)
 // equality
else if (x &lt; y)
 // ...
else
 // y &lt; x
</code></pre>

so still two comparisons in the worst case.

Responding to the comments to this answer: having only a less-than operator to supply makes the containers substantially easier to use, since there's no need to maintain consistency between less-than and equals. Let's imagine you have a program storing floating point numbers. One day, someone decides to replace the bitwise-equality <code>float_equals</code> function, that just happened to be used by some container but also by their code, by an approximate comparison. If that person doesn't update the <code>float_less</code> function, because their code doesn't use that function, then your container code mysteriously breaks.

(Oh and in the example code shown, short-circuiting applies, as always.)

blocks|key|5339641|text|在"Effective+STL“一文中，Scott+Meyer在项目19中对此进行了广泛的讨论|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5339642|5339643|+理解相等和等价之间的区别。|blockquote|5339644|5339645|5339646|正如您所期望的，平等是基于operator==的。|CODE|5339647|等价性“是基于对象值在排序范围内的相对顺序……如果在c的排序顺序中，两个对象都不在另一个对象之前，那么两个对象在容器c中具有等价值。”|5339648|迈尔斯是这样表达的：|5339649|!(+w1+<+w2+)+//+it's+not+true+that+w1+<+w2
&&+++++++++++//+and
!(+w2+<+w1+)+//+it's+not+true+that+w2+<+w1|code-block|syntax|javascript|5339650|迈耶斯随后重申：|5339651|5339652|这是有道理的:如果两个值都不在另一个值之前(根据该标准)，那么两个值是等价的(相对于某种排序标准)。|5339653|5339654|5339655|至于为什么STL这样做：|5339656|5339657|通过只使用一个比较函数，并使用等价作为“相同”含义的仲裁器，标准的关联容器...避免因在标准关联容器中混合使用相等和等价而引起的混淆。|5339658|5339659|5339660|自己阅读第19条(横跨6页的较大部分)，以获得完整的味道。|5339661|entityMap^0|W|4|0|0|1|D|0|0|0|D|A|0|Q|1|1M|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1O|8|@$9|1P|A|1Q|B|N]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1R|8|@$9|1S|A|1T|B|N]|$9|1U|A|1V|B|N]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1W|8|@]|D|@]|E|$]]|$1|S|3|T|5|U|7|1X|8|@]|D|@]|E|$V|W]]|$1|X|3|Y|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|10|3|11|5|I|7|20|8|@]|D|@]|E|$]]|$1|12|3|-4|5|6|7|21|8|@]|D|@]|E|$]]|$1|13|3|-4|5|6|7|22|8|@]|D|@]|E|$]]|$1|14|3|15|5|6|7|23|8|@]|D|@]|E|$]]|$1|16|3|-4|5|6|7|24|8|@]|D|@]|E|$]]|$1|17|3|18|5|I|7|25|8|@]|D|@]|E|$]]|$1|19|3|-4|5|6|7|26|8|@]|D|@]|E|$]]|$1|1A|3|-4|5|6|7|27|8|@]|D|@]|E|$]]|$1|1B|3|1C|5|6|7|28|8|@]|D|@]|E|$]]|$1|1D|3|-4|5|6|7|29|8|@]|D|@]|E|$]]]|1E|$]]

In "Effective STL," Scott Meyers has an extensive discussion about this in Item 19:

<blockquote>
 Understand the difference between equality and equivalence.
</blockquote>

Equality, as you might expect, is based on <code>operator==</code>.

Equivalence "is based on the relative ordering of object values in a sorted range... Two objects have eqivalent values in a container <code>c</code> if neither precedes the other in <code>c</code>'s sort order."

Meyers expresses it this way:

<pre><code>!( w1 &lt; w2 ) // it's not true that w1 &lt; w2
&amp;&amp; // and
!( w2 &lt; w1 ) // it's not true that w2 &lt; w1
</code></pre>

Meyers then restates:

<blockquote>
 This makes sense: two values are equivalent (with respect to some
 ordering criterion) if neither precedes the other (according to that
 criterion.)
</blockquote>

As for why the STL does it this way:

<blockquote>
 By using only a single comparison function and by employing
 equivalence as the arbiter of what it means to be "the same," the
 standard associative containers... avoid the kind of confusion that
 would arise from mixing uses of equality and equivalence within
 standard associative containers.
</blockquote>

Read Item 19 (which spans the better part of 6 pages) for yourself to get the full flavor.

blocks|key|952711|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|952712|首先，这似乎是一种非常低效的比较平等的方式。|blockquote|952713|952714|952715|是的，但排序容器很少执行此测试。|952716|使用像strcmp这样的比较函数会更好。同时使用less-than和compare会更好。|offset|length|style|CODE|952717|952718|在C%2B%2B中，该语句中有多少会被评估(lhs+>+rhs)是真的？|952719|952720|952721|在C和C%2B%2B中，a+&&+b、a+%7C%7C+b、a,+b、a+?+b+:+c从左到右计算，只计算有用的右侧部分(C%2B%2B中的重载+&&、%7C%7C、,运算符除外)。|BOLD|952722|这允许几个有用的简短测试，如：p+!=+NULL+&&+*p+>+2|952723|entityMap^0|0|0|0|0|0|3|6|0|0|0|0|0|8|6|F|6|M|4|R|9|1Q|2|1T|2|1W|1|1N|2|0|F|J|0^^$0|@$1|2|3|-4|4|5|6|Z|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|10|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|11|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|12|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|13|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|14|7|@$J|15|K|16|L|M]]|8|@]|9|$]]|$1|N|3|-4|4|5|6|17|7|@]|8|@]|9|$]]|$1|O|3|P|4|C|6|18|7|@]|8|@]|9|$]]|$1|Q|3|-4|4|5|6|19|7|@]|8|@]|9|$]]|$1|R|3|-4|4|5|6|1A|7|@]|8|@]|9|$]]|$1|S|3|T|4|5|6|1B|7|@$J|1C|K|1D|L|M]|$J|1E|K|1F|L|M]|$J|1G|K|1H|L|M]|$J|1I|K|1J|L|M]|$J|1K|K|1L|L|M]|$J|1M|K|1N|L|M]|$J|1O|K|1P|L|M]|$J|1Q|K|1R|L|U]]|8|@]|9|$]]|$1|V|3|W|4|5|6|1S|7|@$J|1T|K|1U|L|M]]|8|@]|9|$]]|$1|X|3|-4|4|5|6|1V|7|@]|8|@]|9|$]]]|Y|$]]

<blockquote>
 First of all, it seems like a strangely inefficient way to compare for equality 
</blockquote>

Yes, but sorted containers do this test relatively rarely.

Using a compare function like <code>strcmp</code> would be better. Using both less-than and compare would be still better.

<blockquote>
 In C++, how much of that statement would be evaluated (lhs > rhs) was true?
</blockquote>

In C and in C++, <code>a &amp;&amp; b</code>, <code>a || b</code>, <code>a, b</code>, <code>a ? b : c</code> are evaluated left-to-right, with only the useful right part evaluated (except for overloaded <code>&amp;&amp;</code>, <code>||</code>, <code>,</code> operators in C++).

This allows several useful short tests like: <code>p != NULL &amp;&amp; *p &gt; 2</code>

I'm aware that STL associative containers (and other containers being sorted I would guess) use the sorting criterion to test for equality.

The sorting criterion for containers defaults to st::less, so that would make the equality test for a container:

<pre><code>if (! (lhs &lt; rhs || rhs &lt; lhs))
</code></pre>

or something similar. I had a couple questions about this...

First of all, it seems like a strangely inefficient way to compare for equality - why does the STL do it like this? I would have expected STL containers to just take an extra default parameter for equality instead.

My second question is more about the evaluation of the if statement above in general. In C++, how much of that statement would be evaluated (lhs > rhs) was true? Would it stop trying after evaluating the side that failed thus saving some efficiency? If so, which part of the expression is evaluated first?

Equality evaluation in associative containers (STL)

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我知道STL关联容器(以及其他正在排序的容器)使用排序标准来测试相等性。容器的排序标准默认为st::less，因此将对容器进行相等性测试：if (! (lhs < rhs || rhs < lhs))或者类似的东西。关于这个我有几个问题..。首先，这似乎是一种奇怪的低效比较平等的方式-为什么STL要这样做？我原本期望S...

问相联容器(STL)中的相等性计算
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问相联容器(STL)中的相等性计算EN