C / C ++中是否有标准符号函数（signum，sgn）？

Is there a standard sign function (signum, sgn) in C/C++?

我想要一个函数，对于负数返回-1，对于正数返回+1。http://en.wikipedia.org/wiki/sign_函数我自己写这本书很容易，但它似乎应该放在某个标准库的某个地方。

编辑：特别是，我在寻找一个处理浮动的函数。

相关讨论

惊讶的是没有人发布了无分支、类型安全的C++版本：

1
2
3

template <typename T> int sgn(T val) {
return (T(0) < val) - (val < T(0));
}

效益：

实际上实现signum(-1、0或1)。这里使用copysign的实现只返回-1或1，这不是signum。此外，这里的一些实现返回的是浮点(或T)，而不是int，这看起来很浪费。
适用于int、float、double、unsigned short或任何可从integer 0和orderable构造的自定义类型。
快！copysign的速度很慢，特别是当你需要提升然后再缩小的时候。这是无分支的，优化非常出色
符合标准！bitshift hack很简洁，但只适用于某些位表示，并且在有无符号类型时不起作用。在适当的时候，它可以作为手动专业化提供。
准确！与零的简单比较可以保持机器的内部高精度表示(例如x87上的80位)，并避免过早的归零。

Caveats：

它是一个模板，因此需要永远编译。
显然，有些人认为使用一个新的、有点深奥的、非常缓慢的标准库函数，甚至不真正实现signum，这是可以理解的。

当为无符号类型实例化时，检查的< 0部分触发GCC的-Wtype-limits警告。您可以通过使用一些重载来避免这种情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

template <typename T> inline constexpr
int signum(T x, std::false_type is_signed) {
return T(0) < x;
}

template <typename T> inline constexpr
int signum(T x, std::true_type is_signed) {
return (T(0) < x) - (x < T(0));
}

template <typename T> inline constexpr
int signum(T x) {
return signum(x, std::is_signed<T>());
}

(这是第一个警告的好例子。)

相关讨论

"这是一个模板，所以需要永远编译。"嗯？我的意思是，从技术上讲，它根本不是"编译"的，只是经过一次。当您实例化它时，它会被编译，但不会比用特定的T手动编写慢。
@gman:gcc只是在刚才(4.5)停止了模板函数的实例化次数的二次成本，而且它们仍然比手工编写的函数或标准的C预处理器更昂贵地解析和实例化。链接器还必须做更多的工作来删除重复的实例化。模板还鼓励包含在包含中，这使得依赖关系计算需要较长时间和较小的(通常是实现，而不是界面)更改，以强制重新编译更多的文件。
@乔：我同意你的看法，但我认为你夸大了成本；一个函数模板肯定没有明显的成本。
GMAN:一个单符号位不需要复制，但我打赌，如果你正在读这个，你想复制一个以上的符号位，如果你写C++，你有一个以上的模板函数…
@乔：是的，而且还没有明显的费用。C++使用模板，这是我们都必须理解、接受和克服的东西。
如果你认为C++的编译模型没有"明显的成本"，你就永远不会有幸在一个大型的C项目上工作，链接器在一定的时间内花费了大量的时间和时间，而不是用几秒钟或几分钟的时间来衡量。(而且，你似乎在争论我的回答没有真正的警告——也许你应该投票决定？)
@乔：同样，你需要区分"有模板的大型项目"和"我的答案中的单一功能"。你的警告根本不适用。
等等，这是什么"广告文案很慢"的生意？使用当前的编译器(g++4.6+，clang++3.0)，std::copysign似乎为我带来了优秀的代码：4条指令(内联)，没有分支，完全使用fpu。相反，这个答案中给出的方法会产生更糟糕的代码(更多的指令，包括乘法，在整数单元和fpu之间来回移动)。
@snoglethorpe：如果你在int上调用copysign，它会提升到浮动/双精度，并且在返回时必须再次缩小范围。您的编译器可能会优化该升级，但我找不到任何建议，这是由标准保证的。另外，要通过copysign实现signum，您需要手动处理0案例-请确保在任何性能比较中都包含这一点。
第一个版本不是无分支的。为什么人们认为表达式中使用的比较不会生成分支？它将应用于大多数架构。只有具有cmove(或predication)的处理器才会生成无分支代码，但它们也会为三元或if/else(如果这是一个胜利)生成无分支代码。
@Tristopia:你能给我一个例子吗(在一个有合理设置的通用编译器/体系结构上)，在那里生成一个分支(而不是因为它识别出了习惯用法并使用了更有效的分支版本)？
通过将主表达式重写为return (T(0) < val) - (val < T(0));，它只需要定义operator<。您还可以通过将T(0)显式地分配给一个临时的来避免有两个临时的(和构造函数)。编译器无法对更复杂的类型T进行这种优化。
@夜宵：在江户记1〔2〕上说得对。但是constexpr函数体只需要有一个返回语句(+using/typedef)，所以您必须在constexr和优化昂贵的构造函数之间进行选择；在这种情况下，我认为constexr更有用。
@在C++ 14上不再使用USER 7975。所以你可以考虑更新你的答案
Wut？减去bool的标准是如何符合的？
@violetgiraffe-bool可隐式转换为int。false转换为零，true转换为一。
@r.martinhofernandes:是否有标准保证true转换为1，而不仅仅是实现定义的非零值？
@Violetgiraffe是的，那是有保证的。
@帕特里克施勒：我很困惑为什么你认为第一个版本需要cmov或预测来避免分支。在x86上，这可以用setg毫无分支，如这里所示：godbolt.or g/g/xnst9z我对powerpc或arm不太了解，但从godbolt.org上的游戏来看，它似乎也没有分支。
用C++ 11也可以声明SCONExPR用于生成SGN值的编译时间，其中VAL也是一个CONTXPR。
这个答案完全忽略了这一点：它不处理负零的有趣情况。
有一件事我不高兴，那就是SGN(NAN)≠0…
当输入为NaN时，您对返回NaN的最佳方法有什么想法？

我不知道它的标准函数。以下是一种有趣的写作方式：

1	(x > 0) - (x < 0)

以下是一种更易读的方法：

1
2
3

if (x > 0) return 1;
if (x < 0) return -1;
return 0;

如果您喜欢三元运算符，可以这样做：

1	(x > 0) ? 1 : ((x < 0) ? -1 : 0)

相关讨论

也就是没有分支的人。很好。
对x<0计时会很有趣吗？-1:1和1-2*(x<0)。
马克·兰索姆，你的表达对x==0给出了错误的结果。
如果有的话，我会提名这个作为每月风格奖的徽章。
编译器通常会将简单的?:表达式优化为非分支机器代码。
甜的。关于`(x>=0)-(x<=0)'？负为-1，正为1，0为0。
另一个三元是x ? (x < 0) ? -1 : 1 : 0。
一个真实的陈述是否保证在C中是正确的1？
@斯万特："每个运营商都是<、>……如果指定的关系为真，则返回1；如果指定的关系为假，则返回0。"
@斯万特：不完全是。0的值是"假"；任何其他值是"真"；但是关系运算符和相等运算符总是返回0或1(见标准6.5.8和6.5.9)。--表达式a * (x == 42)的值可以是0或a。
因为我是在头上打字而不看规格说明，所以我忘记了零的特殊情况，假设它是正的。对于大多数地方，我会使用一个符号函数，这个定义会起作用。
哦。。。逻辑否定运算符(!也返回0或1。!!x为0，x为0，否则为1:。
@svante：(仍然是关于"true"是1)考虑在中声明的is*函数。7.4.1/1"如果且仅当…"时，此子类中的函数返回非零(真)，因此并非所有"布尔"C函数都只返回0和1。
graphics.stanford.edu/~seander/bithacks.html copyintegersign
高性能马克，我很惊讶你错过了C++标签。这个答案非常有效，不值得投反对票。此外，即使我有完整的x，我也不会使用copysign。
(x＝0)？0:(x/abs(x))。
@Matt Murrell部门通常在CPU上运行缓慢。
是否有人检查过真正平台上的代码gcc/g++/其他编译器发出的代码？我猜"无分支"版本使用两个分支而不是一个。比特移位可能要快得多，而且在性能方面更易于移植。
@我同意。
@j&248；rgenfogh stackoverflow.com/questions/1903954/&hellip；
令人惊叹的。让我大吃一惊的是，在图书馆里，招牌不是标准的；我所知道的每一种语言都是如此。
@例如，在AVR中，您只能逐位移动，因此任何更大的位移动都作为一个循环进行。疼痛。
@嗯，监狱：有趣。我不知道。

有一个名为copysign()的c99数学库函数，它从一个参数中获取符号，从另一个参数中获取绝对值：

1
2
3

result = copysign(1.0, value) // double
result = copysignf(1.0, value) // float
result = copysignl(1.0, value) // long double

根据值的符号，将给出+/-1.0的结果。注意，浮点零有符号：(+0)将产生+1，而(-0)将产生-1。

相关讨论

显然，对原始海报的问题的答案是否定的。没有标准的C++ EDCOX1×3函数。

相关讨论

似乎大多数答案都漏掉了原来的问题。

Is there a standard sign function (signum, sgn) in C/C++?

在标准库中没有，但是有可以通过copysign(1.0, arg)以几乎相同的方式使用的copysign，在boost中有一个真正的符号函数，它可能也是标准的一部分。

1
2
3
4
5

#include <boost/math/special_functions/sign.hpp>

//Returns 1 if x > 0, -1 if x < 0, and 0 if x is zero.
template <class T>
inline int sign (const T& z);

http://www.boost.org/doc/libs/1_47_0/libs/math/doc/sf_and_dist/html/math_toolkit/utils/sign_functions.html

相关讨论

比上述解决方案更快，包括最高评级的解决方案：

1	(x < 0) ? -1 : (x > 0)

相关讨论

Is there a standard sign function (signum, sgn) in C/C++?

是的，取决于定义。

C99及更高版本的signbit()宏位于中。

int signbit(real-floating x);
The signbit macro returns a nonzero value if and only if the sign of its argument value is negative. C11 §7.12.3.6

但是OP想要一些不同的东西。

I want a function that returns -1 for negative numbers and +1 for positive numbers. ... a function working on floats.

1	#define signbit_p1_or_n1(x) ((signbit(x) ? -1 : 1)

更深的：

在以下情况下，该职位并不具体，x = 0.0, -0.0, +NaN, -NaN。

经典的signum()返回+1在x>0上，-1在x>0上，0在x==0上。

许多答案已经涵盖了这一点，但没有涉及到x = -0.0, +NaN, -NaN。许多都是针对一个整数的观点，通常缺少非数字(NaN)和-0.0。

典型答案在-0.0, +NaN, -NaN上的作用类似于signnum_typical()，它们返回0.0, 0.0, 0.0。

1
2
3
4
5

int signnum_typical(double x) {
if (x > 0.0) return 1;
if (x < 0.0) return -1;
return 0;
}

相反，建议使用此功能：在-0.0, +NaN, -NaN上，它返回-0.0, +NaN, -NaN。

1
2
3
4
5

double signnum_c(double x) {
if (x > 0.0) return 1.0;
if (x < 0.0) return -1.0;
return x;
}

相关讨论

有一种不需要分支就可以完成的方法，但它不是很漂亮。

1	sign = -(int)((unsigned int)((int)v) >> (sizeof(int) * CHAR_BIT - 1));

http://graphics.斯坦福.edu/~seander/bithacks.html

那一页上还有很多其他有趣的，非常聪明的东西…

相关讨论

如果您只想测试符号，请使用signbit(如果其参数有负号，则返回true)。不知道为什么您特别希望返回-1或+1；copysign更方便但在某些平台上，它会返回+1，表示负零。只有部分支持负零，其中signbit可能返回true。

相关讨论

一般来说，C/C++中没有标准的符号函数，而缺少这样一个基本的功能，这说明了很多语言。

除此之外，我相信关于定义这样一个函数的正确方法的大多数观点都是正确的，而且一旦考虑到两个重要的警告，"争论"实际上是没有争议的：

signum函数应始终返回其操作数的类型，类似于abs()函数，因为signum通常用于在以某种方式处理后与绝对值相乘。因此，符号的主要用例不是比较而是算术，后者不应该涉及任何昂贵的整数到/从浮点转换。
浮点类型没有一个精确的零值：+0.0可以解释为"零上无穷大"，-0.0可以解释为"零下无穷大"。这就是为什么涉及零的比较必须在内部检查这两个值的原因，并且像EDOCX1[1]这样的表达式可能很危险。

关于C，我认为使用整型的最好方法确实是使用(x > 0) - (x < 0)表达式，因为它应该以无分支的方式转换，并且只需要三个基本操作。最好定义执行与参数类型匹配的返回类型的内联函数，并添加一个c11 define _Generic以将这些函数映射到公共名称。

对于浮点值，我认为基于c11 copysignf(1.0f, x)、copysign(1.0, x)和copysignl(1.0l, x)的内联函数是可行的，因为它们也很可能是无分支的，而且不需要将整数的结果转换回浮点值。您可能需要特别指出的是，由于浮点零值的特殊性、处理时间的考虑，以及在浮点算术中接收正确的-1/+1符号(即使是零值)通常非常有用，因此符号的浮点实现不会返回零。

简而言之，我复制的C揭示了一个称为copysign的标准函数的存在，这可能是有用的。看起来copysign(1.0，-2.0)将返回-1.0，copysign(1.0，2.0)将返回+1.0。

很接近啊？

相关讨论

下面的重载接受的答案确实不会触发-wtype限制，但是它会在is_signed参数上触发-wunused参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

对于C++ 11，另一种选择可能是。

1
2
3
4
5
6
7
8
9
10
11

template <typename T>
typename std::enable_if<std::is_unsigned<T>::value, int>::type
inline constexpr signum(T x) {
return T(0) < x;
}

template <typename T>
typename std::enable_if<std::is_signed<T>::value, int>::type
inline constexpr signum(T x) {
return (T(0) < x) - (x < T(0));
}

对于我来说，它不会触发GCC 5.3.1中的任何警告。

相关讨论

不，它不存在于C++中，就像在Matlab中一样。为此，我在程序中使用了宏。

1	#define sign(a) ( ( (a) < 0 ) ? -1 : ( (a) > 0 ) )

相关讨论

有点偏离主题，但我用这个：

1
2
3
4
5
6
7
8
9

template<typename T>
constexpr int sgn(const T &a, const T &b) noexcept{
return (a > b) - (a < b);
}

template<typename T>
constexpr int sgn(const T &a) noexcept{
return sgn(a, T(0));
}

我发现第一个函数——有两个参数的函数，在"standard"sgn()中更有用，因为它最常用于这样的代码：

1
2
3

int comp(unsigned a, unsigned b){
return sgn( int(a) - int(b) );
}

1
2
3

int comp(unsigned a, unsigned b){
return sgn(a, b);
}

无符号类型没有强制转换，也没有其他减号。

实际上，我有一段代码使用sgn()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

template <class T>
int comp(const T &a, const T &b){
log__("all");
if (a < b)
return -1;

if (a > b)
return +1;

return 0;
}

inline int comp(int const a, int const b){
log__("int");
return a - b;
}

inline int comp(long int const a, long int const b){
log__("long");
return sgn(a, b);
}

如果有增强，可以使用boost/math/special_functions/sign.hpp中的boost::math::sign()方法。

相关讨论

下面是一个支持分支的实现：

1
2
3
4

inline int signum(const double x) {
if(x == 0) return 0;
return (1 - (static_cast<int>((*reinterpret_cast<const uint64_t*>(&x)) >> 63) << 1));
}

除非数据的0是数字的一半，否则分支预测器将选择其中一个分支作为最常见的分支。两个分支只涉及简单的操作。

或者，在某些编译器和CPU体系结构上，完全无分支的版本可能更快：

1
2
3
4

inline int signum(const double x) {
return (x != 0) *
(1 - (static_cast<int>((*reinterpret_cast<const uint64_t*>(&x)) >> 63) << 1));
}

这适用于IEEE754双精度二进制浮点格式：binary64。

1
2
3
4
5

int sign(float n)
{
union { float f; std::uint32_t i; } u { n };
return 1 - ((u.i >> 31) << 1);
}

此函数假定：

浮点数的二进制32表示法
使用命名联合时，对严格别名规则进行异常处理的编译器。

相关讨论

虽然接受的答案中的整数解决方案相当优雅，但它无法为双类型返回NaN，这让我感到困扰，因此我对它进行了轻微的修改。

1
2
3

template <typename T> double sgn(T val) {
return double((T(0) < val) - (val < T(0)))/(val == val);
}

注意，与硬编码的NAN相反，返回浮点NaN会导致在某些实现中设置符号位，因此，val = -NAN和val = NAN的输出将是相同的，无论怎样(如果您喜欢"NAN输出而不是-nan，您可以在返回之前放置abs(val)…)

为什么要使用三元运算符，如果不是，当您可以简单地执行此操作时

1	#define sgn(x) x==0 ? 0 : x/abs(x)

相关讨论

我就在今天碰到这个。好吧，没有标准的方法，但是…

既然OP只需要放大输出范围并将其重新集中在0上，(-1到1而不是0到1)，为什么不把它加倍并减去1呢？

我用过这个：

(x＜0)*2-1

或者，强制进行位移位：

(x＜0)<1-1

但无论如何，编译器可能会对此进行优化。

1	double signof(double a) { return (a == 0) ? 0 : (a<0 ? -1 : 1); }

如何：

1	int sgn = x/fabs(x);

结果应该不错。

相关讨论

用途：

1	`#define sgn(x) (x<0)`

例如：

1	`if(sng(n)) { etc ....}`

或者您可能希望使用一些详细的代码，但首先要强制转换：

inline bool sgn_long(long x)
{
return ((x<0)? true: false); }

相关讨论