blocks|key|3466711|text|对于int，我总是使用min和max宏。我不知道为什么有人会对整数值使用fmin或fmax。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3466712|min和max最大的问题是它们不是函数，即使它们看起来很像。如果你这样做：|3466713|min+(10,+BigExpensiveFunctionCall())|code-block|syntax|javascript|3466714|该函数调用可能会被调用两次，具体取决于宏的实现。因此，在我的组织中，最好的做法是永远不要对不是文字或变量的东西调用min或max。|3466715|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I always use the min and max macros for ints. I'm not sure why anyone would use fmin or fmax for integer values.

The big gotcha with min and max is that they're not functions, even if they look like them. If you do something like:

<pre><code>min (10, BigExpensiveFunctionCall())
</code></pre>

That function call may get called twice depending on the implementation of the macro. As such, its best practice in my org to never call min or max with things that aren't a literal or variable.

blocks|key|3253801|text|fmin和fmax专门用于浮点数(因此使用"f")。如果您将它用于int，您可能会因为转换、函数调用开销等而遭受性能或精度损失，这取决于您的编译器/平台。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3253802|std::min和std::max是模板函数(在header+中定义)，它们使用小于(<)运算符对任何类型进行操作，因此它们可以对允许进行这种比较的任何数据类型进行操作。如果您不想在<上工作，也可以提供自己的比较函数。|3253803|这更安全，因为当参数具有不同的类型时，您必须显式转换参数以匹配它们。例如，编译器不会让您意外地将64位int转换为64位浮点型。仅此原因就应该使模板成为您的默认选择。(归功于Matthieu+M&+bk1e)|3253804|即使与浮点数一起使用，模板也可能在性能上赢得。编译器总是可以选择内联对模板函数的调用，因为源代码是编译单元的一部分。另一方面，有时不可能内联对库函数的调用(共享库，缺少链接时优化，等等)。|BOLD|3253805|entityMap^0|0|4|5|4|0|0|8|9|8|17|1|2J|1|0|0|D|9|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|12|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|13|8|@$9|14|A|15|B|L]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|N|$]]

<code>fmin</code> and <code>fmax</code> are specifically for use with floating point numbers (hence the "f"). If you use it for ints, you may suffer performance or precision losses due to conversion, function call overhead, etc. depending on your compiler/platform.

<code>std::min</code> and <code>std::max</code> are template functions (defined in header <a href="http://en.cppreference.com/w/cpp/header/algorithm" rel="noreferrer"><code>&lt;algorithm&gt;</code></a>) which work on any type with a less-than (<code>&lt;</code>) operator, so they can operate on any data type that allows such a comparison. You can also provide your own comparison function if you don't want it to work off <code>&lt;</code>.

This is safer since you have to explicitly convert arguments to match when they have different types. The compiler won't let you accidentally convert a 64-bit int into a 64-bit float, for example. This reason alone should make the templates your default choice. (Credit to Matthieu M &amp; bk1e)

Even when used with floats the template may win in performance. A compiler always has the option of inlining calls to template functions since the source code is part of the compilation unit. Sometimes it's impossible to inline a call to a library function, on the other hand (shared libraries, absence of link-time optimization, etc.).

blocks|key|410276|text|如果您使用的是C%2B%2B，我更喜欢C%2B%2B的最小/最大函数，因为它们是特定于类型的。fmin/fmax将强制将所有内容转换为浮点数或从浮点数转换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|410277|此外，只要您为用户定义的类型定义了operator<，C%2B%2B最小/最大函数就可以处理这些类型。|410278|HTH|410279|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I would prefer the C++ min/max functions, if you are using C++, because they are type-specific. fmin/fmax will force everything to be converted to/from floating point.

Also, the C++ min/max functions will work with user-defined types as long as you have defined operator&lt; for those types.

HTH

blocks|key|413625|text|std::min和std::max是模板。因此，它们可以用于提供小于运算符的各种类型，包括浮点数、双精度、长双精度。所以，如果你想写通用的C%2B%2B代码，你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|413626|template<typename+T>
T+const&+max3(T+const&+a,+T+const&+b,+T+const&+c)
{
+++using+std::max;
+++return+max(max(a,b),c);+//+non-qualified+max+allows+ADL
}|code-block|syntax|javascript|413627|至于性能，我不认为fmin和fmax与它们的C%2B%2B对应产品有什么不同。|offset|length|style|CODE|413628|entityMap^0|0|0|9|4|E|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

std::min and std::max are templates. So, they can be used on a variety of types that provide the less than operator, including floats, doubles, long doubles. So, if you wanted to write generic C++ code you'd do something like this:

<pre><code>template&lt;typename T&gt;
T const&amp; max3(T const&amp; a, T const&amp; b, T const&amp; c)
{
 using std::max;
 return max(max(a,b),c); // non-qualified max allows ADL
}
</code></pre>

As for performance, I don't think <code>fmin</code> and <code>fmax</code> differ from their C++ counterparts.

blocks|key|3253934|text|fmin和fmax仅适用于浮点和双精度变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3253935|min和max是模板函数，允许在给定二元谓词的情况下比较任何类型。它们还可以与其他算法一起使用，以提供复杂的功能。|3253936|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

fmin and fmax are only for floating point and double variables.

min and max are template functions that allow comparison of any types, given a binary predicate. They can also be used with other algorithms to provide complex functionality.

blocks|key|3253953|text|正如您已经注意到的，fmin和fmax是在C99中引入的。标准C%2B%2B库没有fmin和fmax函数。在将C99标准库整合到C%2B%2B+(如果有的话)之前，这些函数的应用程序区域是完全分开的。在任何情况下，你都不需要“更喜欢”其中一个。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3253954|您只需在C%2B%2B中使用模板化的std::min/std::max，并使用C中提供的任何内容。|3253955|entityMap^0|A|4|F|4|11|4|16|4|0|E|8|N|8|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|I|$]]

As you noted yourself, <code>fmin</code> and <code>fmax</code> were introduced in C99. Standard C++ library doesn't have <code>fmin</code> and <code>fmax</code> functions. Until C99 standard library gets incorporated into C++ (if ever), the application areas of these functions are cleanly separated. There's no situation where you might have to "prefer" one over the other.

You just use templated <code>std::min</code>/<code>std::max</code> in C++, and use whatever is available in C.

blocks|key|415972|text|如果您的实现提供了64位整数类型，则使用fmin或fmax可能会得到不同的(不正确的)答案。您的64位整数将被转换为双精度，这将(至少通常)有一个小于64位的有效数。当您将这样的数字转换为双精度数时，一些最低有效位可能/将完全丢失。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|415973|这意味着，当转换为double时，两个真正不同的数字最终可能相等--结果将是不正确的数字，这不一定等于原始输入中的任何一个。|415974|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If your implementation provides a 64-bit integer type, you may get a different (incorrect) answer by using fmin or fmax. Your 64-bit integers will be converted to doubles, which will (at least usually) have a significand that's smaller than 64-bits. When you convert such a number to a double, some of the least significant bits can/will be lost completely.

This means that two numbers that were really different could end up equal when converted to double -- and the result will be that incorrect number, that's not necessarily equal to either of the original inputs.

blocks|key|3254029|text|在比较有符号和无符号整数时，fminl和fmaxl的fmin和fmax可能是首选-您可以利用这样一个事实，即整个范围的有符号和无符号数字，您不必担心整数范围和升迁。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3254030|unsigned+int+x+=+4000000000;
int+y+=+-1;

int+z+=+min(x,+y);
z+=+(int)fmin(x,+y);|code-block|syntax|javascript|3254031|entityMap^0|E|5|K|5|Q|4|V|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|L|$]]

<code>fmin</code> and <code>fmax</code>, of <code>fminl</code> and <code>fmaxl</code> could be preferred when comparing signed and unsigned integers - you can take advantage of the fact that the entire range of signed and unsigned numbers and you don't have to worry about integer ranges and promotions.

<pre><code>unsigned int x = 4000000000;
int y = -1;

int z = min(x, y);
z = (int)fmin(x, y);
</code></pre>

blocks|key|416021|text|使用std::min和std::max。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|416022|如果其他版本更快，那么您的实现可以为这些版本添加重载，您将获得性能和可移植性的好处：|416023|template+<typename+T>
T+min+(T,+T)+{
++//+...+default
}

inline+float+min+(float+f1,+float+f2)+{
+return+fmin(+f1,+f2);
}++++|code-block|syntax|javascript|416024|entityMap^0|2|8|B|8|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Use <code>std::min</code> and <code>std::max</code>.

If the other versions are faster then your implementation can add overloads for these and you'll get the benefit of performance and portability:

<pre><code>template &lt;typename T&gt;
T min (T, T) {
 // ... default
}

inline float min (float f1, float f2) {
 return fmin( f1, f2);
} 
</code></pre>

blocks|key|3467057|text|正如Richard+Corden所指出的，使用在std命名空间中定义的C%2B%2B函数min和max。它们提供了类型安全，并有助于避免比较混合类型(即浮点型与整型)，这有时可能是不可取的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3467058|如果您发现您使用C%2B%2B库也将min/max定义为宏，这可能会导致冲突，那么您可以通过这种方式防止不需要的宏替换调用min/max函数(请注意额外的括号)：|3467059|(std::min)(x,+y)
(std::max)(x,+y)|code-block|syntax|javascript|3467060|请记住，这将有效地禁用Argument+Dependant+Lookup+(+ADL，也称为Koenig+lookup)，以防您想要依赖ADL。|offset|length|3467061|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Argument_dependent_name_lookup^0|0|0|0|B|P|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|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

As Richard Corden pointed, use C++ functions min and max defined in std namespace. They provide type safety, and help to avoid comparing mixed types (i.e. float point vs integer) what sometimes may be undesirable. 

If you find that C++ library you use defines min/max as macros as well, it may cause conflicts, then you can prevent unwanted macro substitution calling the min/max functions this way (notice extra brackets):

<pre><code>(std::min)(x, y)
(std::max)(x, y)
</code></pre>

Remember, this will effectively disable <a href="http://en.wikipedia.org/wiki/Argument_dependent_name_lookup" rel="nofollow noreferrer">Argument Dependant Lookup</a> (ADL, also called Koenig lookup), in case you want to rely on ADL.

blocks|key|416048|text|您错过了fmin和fmax的全部要点。它被包括在C99中，以便现代CPU可以使用它们的本机(读取SSE)指令来处理浮点最小和最大浮点，并避免测试和分支(因此可能会预测错误的分支)。我重写了使用std::min和std::max的代码，以便在内部循环中使用SSE内部函数作为min和max，加速效果非常显著。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|416049|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|$]]

You're missing the entire point of fmin and fmax. It was included in C99 so that modern CPUs could use their native (read SSE) instructions for floating point min and max and avoid a test and branch (and thus a possibly mis-predicted branch). I've re-written code that used std::min and std::max to use SSE intrinsics for min and max in inner loops instead and the speed-up was significant.

blocks|key|3254120|text|顺便说一下，在cstdlib中，您可以使用__min和__max。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3254121|更多信息：http://msdn.microsoft.com/zh-cn/library/btkhtd8d.aspx|3254122|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/zh-cn/library/btkhtd8d.aspx^0|7|7|L|5|R|5|0|5|1H|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|H|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

By the way, in <code>cstdlib</code> there are <code>__min</code> and <code>__max</code> you can use.

For more: <a href="http://msdn.microsoft.com/zh-cn/library/btkhtd8d.aspx" rel="nofollow">http://msdn.microsoft.com/zh-cn/library/btkhtd8d.aspx</a>

blocks|key|3467132|text|std::min、std::max和fmin与fmax之间有一个重要的区别。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3467133|std::min(-0.0,0.0)+=+-0.0
std::max(-0.0,0.0)+=+-0.0|code-block|syntax|javascript|3467134|鉴于|3467135|fmin(-0.0,+0.0)+=+-0.0
fmax(-0.0,+0.0)+=++0.0|3467136|因此，std::min不是fmin的1:1替代品。函数std::min和std::max是不可交换的。要获得与fmin和fmax的doubles相同的结果，应该交换参数|3467137|fmin(-0.0,+0.0)+=+std::min(-0.0,++0.0)
fmax(-0.0,+0.0)+=+std::max(+0.0,+-0.0)|3467138|但就我所能告诉all+these+functions+are+implementation+defined+anyway+in+this+case的是，要100%25确定你必须测试它们是如何实现的。|3467139|3467140|还有另一个重要的区别。对于x+!+=+NaN|3467141|std::max(Nan,x)+=+NaN
std::max(x,NaN)+=+x
std::min(Nan,x)+=+NaN
std::min(x,NaN)+=+x|3467142|3467143|fmax(Nan,x)+=+x
fmax(x,NaN)+=+x
fmin(Nan,x)+=+x
fmin(x,NaN)+=+x|3467144|3467145|可以用以下代码模拟fmax|3467146|double+myfmax(double+x,+double+y)
{
+++//+z+>+nan+for+z+!=+nan+is+required+by+C+the+standard
+++int+xnan+=+isnan(x),+ynan+=+isnan(y);
+++if(xnan+%7C%7C+ynan)+{
++++++++if(xnan+&&+!ynan)+return+y;
++++++++if(!xnan+&&+ynan)+return+x;
++++++++return+x;
+++}
+++//+%2B0+>+-0+is+preferred+by+C+the+standard+
+++if(x==0+&&+y==0)+{
+++++++int+xs+=+signbit(x),+ys+=+signbit(y);
+++++++if(xs+&&+!ys)+return+y;
+++++++if(!xs+&&+ys)+return+x;
+++++++return+x;
+++}
+++return+std::max(x,y);
}|3467147|这表明std::max是fmax的一个子集。|3467148|查看程序集可以看到，Clang为fmax和fmin使用了内置代码，而GCC则从一个数学库中调用它们。用于带有-O3的fmax的clang程序集为|3467149|movapd++xmm2,+xmm0
cmpunordsd++++++xmm2,+xmm2
movapd++xmm3,+xmm2
andpd+++xmm3,+xmm1
maxsd+++xmm1,+xmm0
andnpd++xmm2,+xmm1
orpd++++xmm2,+xmm3
movapd++xmm0,+xmm2|3467150|而对于std::max(double,+double)，它只是简单地|3467151|maxsd+++xmm0,+xmm1|3467152|然而，对于GCC和克朗来说，使用-Ofast+fmax变得很简单|3467153|maxsd+++xmm0,+xmm1|3467154|因此，这再次表明std::max是fmax的子集，并且当您使用没有nan或带符号0的松散浮点模型时，fmax和std::max是相同的。显然，同样的论点也适用于fmin和std::min。|3467155|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/30913952/minimum-and-maximum-of-signed-zero/30914285?noredirect=1#comment49866669_30914285^0|0|8|9|8|I|4|N|4|0|0|0|0|3|8|D|4|R|8|10|8|1J|4|1O|4|0|0|7|1U|0|0|0|D|9|0|0|0|0|0|9|4|0|0|3|8|C|4|0|G|4|L|4|1I|3|1M|4|0|0|3|O|0|0|G|6|N|4|0|0|8|8|H|4|X|3|1E|4|1J|8|28|4|2D|8|0^^$0|@$1|2|3|4|5|6|7|1V|8|@$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|24|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|25|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|26|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|27|8|@$9|28|A|29|B|C]|$9|2A|A|2B|B|C]|$9|2C|A|2D|B|C]|$9|2E|A|2F|B|C]|$9|2G|A|2H|B|C]|$9|2I|A|2J|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|2K|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|2L|8|@]|D|@$9|2M|A|2N|1|2O]]|E|$]]|$1|U|3|-4|5|6|7|2P|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|2Q|8|@$9|2R|A|2S|B|C]]|D|@]|E|$]]|$1|X|3|Y|5|H|7|2T|8|@]|D|@]|E|$I|J]]|$1|Z|3|L|5|6|7|2U|8|@]|D|@]|E|$]]|$1|10|3|11|5|H|7|2V|8|@]|D|@]|E|$I|J]]|$1|12|3|-4|5|6|7|2W|8|@]|D|@]|E|$]]|$1|13|3|14|5|6|7|2X|8|@$9|2Y|A|2Z|B|C]]|D|@]|E|$]]|$1|15|3|16|5|H|7|30|8|@]|D|@]|E|$I|J]]|$1|17|3|18|5|6|7|31|8|@$9|32|A|33|B|C]|$9|34|A|35|B|C]]|D|@]|E|$]]|$1|19|3|1A|5|6|7|36|8|@$9|37|A|38|B|C]|$9|39|A|3A|B|C]|$9|3B|A|3C|B|C]|$9|3D|A|3E|B|C]]|D|@]|E|$]]|$1|1B|3|1C|5|H|7|3F|8|@]|D|@]|E|$I|J]]|$1|1D|3|1E|5|6|7|3G|8|@$9|3H|A|3I|B|C]]|D|@]|E|$]]|$1|1F|3|1G|5|H|7|3J|8|@]|D|@]|E|$I|J]]|$1|1H|3|1I|5|6|7|3K|8|@$9|3L|A|3M|B|C]|$9|3N|A|3O|B|C]]|D|@]|E|$]]|$1|1J|3|1K|5|H|7|3P|8|@]|D|@]|E|$I|J]]|$1|1L|3|1M|5|6|7|3Q|8|@$9|3R|A|3S|B|C]|$9|3T|A|3U|B|C]|$9|3V|A|3W|B|C]|$9|3X|A|3Y|B|C]|$9|3Z|A|40|B|C]|$9|41|A|42|B|C]|$9|43|A|44|B|C]]|D|@]|E|$]]|$1|1N|3|-4|5|6|7|45|8|@]|D|@]|E|$]]]|1O|$1P|$5|1Q|1R|1S|E|$1T|1U]]]]

There is an important difference between <code>std::min</code>, <code>std::max</code> and <code>fmin</code> and <code>fmax</code>.

<pre><code>std::min(-0.0,0.0) = -0.0
std::max(-0.0,0.0) = -0.0
</code></pre>

whereas

<pre><code>fmin(-0.0, 0.0) = -0.0
fmax(-0.0, 0.0) = 0.0
</code></pre>

So <code>std::min</code> is not a 1-1 substitute for <code>fmin</code>. The functions <code>std::min</code> and <code>std::max</code> are not commutative. To get the same result with doubles with <code>fmin</code> and <code>fmax</code> one should swap the arguments

<pre><code>fmin(-0.0, 0.0) = std::min(-0.0, 0.0)
fmax(-0.0, 0.0) = std::max( 0.0, -0.0)
</code></pre>

But as far as I can tell <a href="https://stackoverflow.com/questions/30913952/minimum-and-maximum-of-signed-zero/30914285?noredirect=1#comment49866669_30914285">all these functions are implementation defined anyway in this case</a> so to be 100% sure you have to test how they are implemented.

<hr>

There is another important difference. For <code>x ! = NaN</code>:

<pre><code>std::max(Nan,x) = NaN
std::max(x,NaN) = x
std::min(Nan,x) = NaN
std::min(x,NaN) = x
</code></pre>

whereas

<pre><code>fmax(Nan,x) = x
fmax(x,NaN) = x
fmin(Nan,x) = x
fmin(x,NaN) = x
</code></pre>

<hr>

<code>fmax</code> can be emulated with the following code

<pre><code>double myfmax(double x, double y)
{
 // z &gt; nan for z != nan is required by C the standard
 int xnan = isnan(x), ynan = isnan(y);
 if(xnan || ynan) {
 if(xnan &amp;&amp; !ynan) return y;
 if(!xnan &amp;&amp; ynan) return x;
 return x;
 }
 // +0 &gt; -0 is preferred by C the standard 
 if(x==0 &amp;&amp; y==0) {
 int xs = signbit(x), ys = signbit(y);
 if(xs &amp;&amp; !ys) return y;
 if(!xs &amp;&amp; ys) return x;
 return x;
 }
 return std::max(x,y);
}
</code></pre>

This shows that <code>std::max</code> is a subset of <code>fmax</code>.

Looking at the assembly shows that Clang uses builtin code for <code>fmax</code> and <code>fmin</code> whereas GCC calls them from a math library. The assembly for clang for <code>fmax</code> with <code>-O3</code> is

<pre><code>movapd xmm2, xmm0
cmpunordsd xmm2, xmm2
movapd xmm3, xmm2
andpd xmm3, xmm1
maxsd xmm1, xmm0
andnpd xmm2, xmm1
orpd xmm2, xmm3
movapd xmm0, xmm2
</code></pre>

whereas for <code>std::max(double, double)</code> it is simply

<pre><code>maxsd xmm0, xmm1
</code></pre>

However, for GCC and Clang using <code>-Ofast</code> <code>fmax</code> becomes simply

<pre><code>maxsd xmm0, xmm1
</code></pre>

So this shows once again that <code>std::max</code> is a subset of <code>fmax</code> and that when you use a looser floating point model which does not have <code>nan</code> or signed zero then <code>fmax</code> and <code>std::max</code> are the same. The same argument obviously applies to <code>fmin</code> and <code>std::min</code>.

blocks|key|3467224|text|针对具有SSE指令的处理器的C%2B%2B实现不能提供std::min和std::max的专门化，用于类型float、double和long+doubleE29，它们分别等同于E110E211、E112fminE213和E114E215？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|3467225|专门化将为浮点类型提供更好的性能，而通用模板将处理非浮点类型，而不会像fmin和fmaxes那样尝试强制将浮点类型转换为浮点类型。|3467226|entityMap^0|N|8|W|8|1D|5|1J|6|1Q|1H|21|F|0|0|1T|0^^$0|@$1|2|3|4|5|6|7|K|8|@$9|L|A|M|B|C]|$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|X|8|@$9|Y|A|Z|B|C]]|E|@]|F|$]]|$1|I|3|-4|5|6|7|10|8|@]|E|@]|F|$]]]|J|$]]

Couldn't a C++ implementation targeted for processors with SSE instructions provide specializations of std::min and std::max for types float, double, and long double which do the equivalent of fminf, fmin, and fminl, respectively?

The specializations would provide better performance for floating-point types while the general template would handle non-floating-point types without attempting to coerce floating-point types into floating-point types that way the fmins and fmaxes would.

From C++, are <code>std::min</code> and <code>std::max</code> preferable over <code>fmin</code> and <code>fmax</code>? For comparing two integers, do they provide basically the same functionality?
Do you tend to use one of these sets of functions or do you prefer to write your own (perhaps to improve efficiency, portability, flexibility, etc.)?
Notes:
<ol>
<li>The C++ Standard Template Library (STL) declares the <code>min</code> and <code>max</code> functions in the standard C++ <a href="http://en.wikipedia.org/wiki/Algorithm_(C%2B%2B)" rel="nofollow noreferrer">algorithm</a> header.
</li>
<li>The C standard (C99) provides the <code>fmin</code> and <code>fmax</code> function in the standard C <a href="http://en.wikipedia.org/wiki/Math.h" rel="nofollow noreferrer">math.h</a> header.
</li>
</ol>
Thanks in advance!

Use of min and max functions in C++

编译器

在C++中，std::min和std::max比fmin和fmax更可取吗？对于比较两个整数，它们是否提供了基本相同的功能？您是倾向于使用这些函数中的一个，还是更喜欢编写自己的函数(可能是为了提高效率、可移植性、灵活性等)？备注： C++标准模板库在标准的C++ 头文件中声明min和max函数。C标准(C99)在标准C...

问在C++中使用min和max函数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中使用min和max函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中使用min和max函数
EN