当前位置：文江博客话题详情

检查两个整数是否具有相同符号的最简单方法？

发布于 2024-07-04 13:50:18 字数 53 浏览 10 评论 0原文

检查两个整数是否具有相同符号的最简单方法是什么？有没有什么简短的按位技巧可以做到这一点？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

萌辣 2024-07-11 13:50:18

如果(x*y)> 0...

假设非零等等。

回复收藏 0 原文

贩梦商人 2024-07-11 13:50:18

假设二进制补码算术（http://en.wikipedia.org/wiki/Two_complement）：

inline bool same_sign(int x, int y) {
    return (x^y) >= 0;
}

在经过优化的现代处理器上，这只需两条指令，耗时不到 1 纳秒。

不假设二进制补码算术：

inline bool same_sign(int x, int y) {
    return (x<0) == (y<0);
}

这可能需要一两个额外的指令并且需要更长的时间。

使用乘法是一个坏主意，因为它容易溢出。

Assuming twos complement arithmetic (http://en.wikipedia.org/wiki/Two_complement):

inline bool same_sign(int x, int y) {
    return (x^y) >= 0;
}

This can take as little as two instructions and less than 1ns on a modern processor with optimization.

Not assuming twos complement arithmetic:

inline bool same_sign(int x, int y) {
    return (x<0) == (y<0);
}

This may require one or two extra instructions and take a little longer.

Using multiplication is a bad idea because it is vulnerable to overflow.

回复收藏 0 原文

陌生 2024-07-11 13:50:18

(整数1 * 整数2)> 0

因为当两个整数共用一个符号时，相乘的结果将始终为正。

如果您无论如何都想将 0 视为相同的符号，也可以使其 >= 0。

回复收藏 0 原文

海未深 2024-07-11 13:50:18

假设 32 位整数：

bool same = ((x ^ y) >> 31) != 1;

稍微简洁一些：

bool same = !((x ^ y) >> 31);

Assuming 32 bit ints:

bool same = ((x ^ y) >> 31) != 1;

Slightly more terse:

bool same = !((x ^ y) >> 31);

回复收藏 0 原文

黎夕旧梦 2024-07-11 13:50:18

我不太确定我是否会将“按位技巧”和“最简单”视为同义词。我看到很多答案都假设有符号 32 位整数（尽管要求无符号会很愚蠢）；我不确定它们是否适用于浮点值。

似乎“最简单”的检查是比较两个值与 0 的比较；假设可以比较类型，这是非常通用的：

bool compare(T left, T right)
{
    return (left < 0) == (right < 0);
}

如果符号相反，则结果为 false。如果迹象相同，则说明正确。

I'm not really sure I'd consider "bitwise trick" and "simplest" to be synonymous. I see a lot of answers that are assuming signed 32-bit integers (though it would be silly to ask for unsigned); I'm not certain they'd apply to floating-point values.

It seems like the "simplest" check would be to compare how both values compare to 0; this is pretty generic assuming the types can be compared:

bool compare(T left, T right)
{
    return (left < 0) == (right < 0);
}

If the signs are opposite, you get false. If the signs are the same, you get true.

回复收藏 0 原文

入怼 2024-07-11 13:50:18

使用 std::signbit 的更好方法如下：

std::signbit(firstNumber) == std::signbit(secondNumber);

它还支持其他基本类型（double、float、char 等）。

Better way using std::signbit as follows:

std::signbit(firstNumber) == std::signbit(secondNumber);

It also support other basic types (double, float, char etc).

回复收藏 0 原文

林空鹿饮溪 2024-07-11 13:50:18

#include<stdio.h>

int checksign(int a, int b)
{
 return (a ^ b); 
}

void  main()
{
    int a=-1, b = 0;

    if(checksign(a,b)<0)
    {
        printf("Integers have the opposite sign");
    }
    else
    {
        printf("Integers have the same sign");
    }
}

#include<stdio.h>

int checksign(int a, int b)
{
 return (a ^ b); 
}

void  main()
{
    int a=-1, b = 0;

    if(checksign(a,b)<0)
    {
        printf("Integers have the opposite sign");
    }
    else
    {
        printf("Integers have the same sign");
    }
}

回复收藏 0 原文

丢了幸福的猪 2024-07-11 13:50:18

作为技术说明，即使在现代架构上，位运算解决方案也将比乘法高效得多。您只节省了大约 3 个周期，但您知道他们所说的“节省一分钱”......

回复收藏 0 原文

好多鱼好多余 2024-07-11 13:50:18

就在我头顶上...

int mask = 1 << 31;
(a & mask) ^ (b & mask) < 0;

Just off the top of my head...

int mask = 1 << 31;
(a & mask) ^ (b & mask) < 0;

回复收藏 0 原文

帅气尐潴 2024-07-11 13:50:18

if (a*b < 0) 符号不同，否则符号相同（或 a 或 b 为零）

回复收藏 0 原文

陌路黄昏 2024-07-11 13:50:18

无分支 C 版本：

int sameSign(int a, int b) {
    return ~(a^b) & (1<<(sizeof(int)*8-1));
}

整数类型的 C++ 模板：

template <typename T> T sameSign(T a, T b) {
    return ~(a^b) & (1<<(sizeof(T)*8-1));
}

branchless C version:

int sameSign(int a, int b) {
    return ~(a^b) & (1<<(sizeof(int)*8-1));
}

C++ template for integer types:

template <typename T> T sameSign(T a, T b) {
    return ~(a^b) & (1<<(sizeof(T)*8-1));
}

回复收藏 0 原文

白云不回头 2024-07-11 13:50:18

对于任意大小的 int 进行二进制补码算术：

#define SIGNBIT (~((unsigned int)-1 >> 1))
if ((x & SIGNBIT) == (y & SIGNBIT))
    // signs are the same

For any size of int with two's complement arithmetic:

#define SIGNBIT (~((unsigned int)-1 >> 1))
if ((x & SIGNBIT) == (y & SIGNBIT))
    // signs are the same

回复收藏 0 原文

阳光的暖冬 2024-07-11 13:50:18

假设 32 位

if(((x^y) & 0x80000000) == 0)

...答案 if(x*y>0) 不好，因为溢出

回复收藏 0 原文

滥情哥ㄟ 2024-07-11 13:50:18

回想一下我的大学时代，在大多数机器表示中，整数的最左边的位不就是负数时为 1，正数时为 0 吗？

不过，我想这相当依赖于机器。

回复收藏 0 原文

尬尬 2024-07-11 13:50:18

int same_sign = !( (x >> 31) ^ (y >> 31) );

如果（相同的符号）...
别的 ...

回复收藏 0 原文

短暂陪伴 2024-07-11 13:50:18

这是一个在 C/C++ 中工作的版本，不依赖于整数大小或存在溢出问题（即 x*y>=0 不起作用）

bool SameSign(int x, int y)
{
    return (x >= 0) ^ (y < 0);
}

当然，您可以 geek out 和模板：

template <typename valueType>
bool SameSign(typename valueType x, typename valueType y)
{
    return (x >= 0) ^ (y < 0);
}

注意：因为我们使用异或，当符号相同时，我们希望 LHS 和 RHS 不同，因此对零进行不同的检查。

Here is a version that works in C/C++ that doesn't rely on integer sizes or have the overflow problem (i.e. x*y>=0 doesn't work)

bool SameSign(int x, int y)
{
    return (x >= 0) ^ (y < 0);
}

Of course, you can geek out and template:

template <typename valueType>
bool SameSign(typename valueType x, typename valueType y)
{
    return (x >= 0) ^ (y < 0);
}

Note: Since we are using exclusive or, we want the LHS and the RHS to be different when the signs are the same, thus the different check against zero.

回复收藏 0 原文