使用按位运算符检查数字是正数还是负数

Question

我可以使用按位运算符检查数字是否为奇数/偶数。我可以在不使用任何条件语句/运算符（如 if/三元等）的情况下检查数字是否为正/零/负。

可以使用按位运算符和 C 或 C++ 中的一些技巧来完成同样的操作吗？

Answer 1

我可以在不使用任何条件语句/运算符（如 if/三元等）的情况下检查数字是否为正/零/负吗？

当然：

bool is_positive = number > 0;
bool is_negative = number < 0;
bool is_zero = number == 0;

Answer 2

如果高位设置为有符号整数（字节、长整数等，但不是浮点数），则该数字为负数。

int x = -2300;  // assuming a 32-bit int

if ((x & 0x80000000) != 0)
{
    // number is negative
}

添加：

您说过您不想使用任何条件。我想你可以这样做：

int isNegative = (x & 0x80000000);

稍后你可以使用 if (isNegative) 来测试它。

Answer 3

或者，您可以使用 signbit()工作已经为您完成。

我假设在幕后，math.h 实现是一种有效的按位检查（可能解决您最初的目标）。

参考：http://en.cppreference.com/w/cpp/numeric/math /符号位

Answer 4

Bit Twiddling Hacks 页面上有详细的讨论。

int v;      // we want to find the sign of v
int sign;   // the result goes here 

// CHAR_BIT is the number of bits per byte (normally 8).
sign = -(v < 0);  // if v < 0 then -1, else 0. 
// or, to avoid branching on CPUs with flag registers (IA32):
sign = -(int)((unsigned int)((int)v) >> (sizeof(int) * CHAR_BIT - 1));
// or, for one less instruction (but not portable):
sign = v >> (sizeof(int) * CHAR_BIT - 1); 

// The last expression above evaluates to sign = v >> 31 for 32-bit integers.
// This is one operation faster than the obvious way, sign = -(v < 0). This
// trick works because when signed integers are shifted right, the value of the
// far left bit is copied to the other bits. The far left bit is 1 when the value
// is negative and 0 otherwise; all 1 bits gives -1. Unfortunately, this behavior
// is architecture-specific.

// Alternatively, if you prefer the result be either -1 or +1, then use:

sign = +1 | (v >> (sizeof(int) * CHAR_BIT - 1));  // if v < 0 then -1, else +1

// On the other hand, if you prefer the result be either -1, 0, or +1, then use:

sign = (v != 0) | -(int)((unsigned int)((int)v) >> (sizeof(int) * CHAR_BIT - 1));
// Or, for more speed but less portability:
sign = (v != 0) | (v >> (sizeof(int) * CHAR_BIT - 1));  // -1, 0, or +1
// Or, for portability, brevity, and (perhaps) speed:
sign = (v > 0) - (v < 0); // -1, 0, or +1

// If instead you want to know if something is non-negative, resulting in +1
// or else 0, then use:

sign = 1 ^ ((unsigned int)v >> (sizeof(int) * CHAR_BIT - 1)); // if v < 0 then 0, else 1

// Caveat: On March 7, 2003, Angus Duggan pointed out that the 1989 ANSI C
// specification leaves the result of signed right-shift implementation-defined,
// so on some systems this hack might not work. For greater portability, Toby
// Speight suggested on September 28, 2005 that CHAR_BIT be used here and
// throughout rather than assuming bytes were 8 bits long. Angus recommended
// the more portable versions above, involving casting on March 4, 2006.
// Rohit Garg suggested the version for non-negative integers on September 12, 2009. 

Answer 5

#include<stdio.h>

void main()
{
    int n;  // assuming int to be 32 bit long

    //shift it right 31 times so that MSB comes to LSB's position
    //and then and it with 0x1
    if ((n>>31) & 0x1 == 1) {
        printf("negative number\n");
    } else {
        printf("positive number\n");
    }

    getch();
}

Answer 6

有符号整数和浮点通常使用最高有效位来存储符号，因此如果您知道大小，则可以从最高有效位提取信息。

这样做通常没有什么好处，因为需要进行某种比较才能使用此信息，并且处理器测试某事物是否为负就像测试它是否不为零一样容易。事实上，在 ARM 处理器上，检查最高有效位通常比预先检查它是否为负值更昂贵。

Answer 7

它非常简单，

可以很容易地完成，它

return ((!!x) | (x >> 31));

返回

• 1 表示正数，
• -1 表示负数，
• 0 表示零

Answer 8

这不能通过 C 中的位运算以可移植的方式完成。标准允许的有符号整数类型的表示可能比您想象的要奇怪得多。特别是，符号位打开且为零的值不必是有符号类型或无符号类型的允许值，而是这两种类型的所谓陷阱表示。

因此，您可以使用位运算符进行的所有计算都可能会产生导致未定义行为的结果。

---

在任何情况下，正如其他一些答案所暗示的那样，这并不是真正必要的，与 < 或 > 进行比较在任何实际情况下都应该足够了，更高效、更容易阅读...所以就这样做。

Answer 9

// if (x < 0) return -1
// else if (x == 0) return 0
// else return 1
int sign(int x) {
  // x_is_not_zero = 0 if x is 0 else x_is_not_zero = 1
  int x_is_not_zero = (( x | (~x + 1)) >> 31) & 0x1;
  return (x & 0x01 << 31) >> 31 | x_is_not_zero; // for minux x, don't care the last operand 
}

这正是您想要的！

Answer 10

这是针对这个老问题的与 C++11 相关的更新。还值得考虑 std::signbit。

在使用 gcc 7.3 64 位和 -O3 优化的编译器资源管理器上，此代码

bool s1(double d)
{
    return d < 0.0;
}

生成

s1(double):
  pxor xmm1, xmm1
  ucomisd xmm1, xmm0
  seta al
  ret

并且此代码

bool s2(double d)
{
    return std::signbit(d);
}

生成

s2(double):
  movmskpd eax, xmm0
  and eax, 1
  ret

您需要进行分析以确保存在任何速度差异，但符号位版本确实使用了 1 个较少的操作码。

Answer 11

当您确定整数的大小时（假设为 16 位 int）：

bool is_negative = (unsigned) signed_int_value >> 15;

当您不确定整数的大小时：

bool is_negative = (unsigned) signed_int_value >> (sizeof(int)*8)-1; //where 8 is bits

unsigned 关键字是可选的。

Answer 12

if( (num>>sizeof(int)*8 - 1) == 0 )
    // number is positive
else
   // number is negative

如果值为 0，则数字为正，否则为负

Answer 13

判断数字是正数还是负数的更简单方法：
设数字为x
检查是否 [x * (-1)] > x。如果 true x 为负值，则为正值。

Answer 14

您可以通过查看最高有效位来区分负数/非负数。
在有符号整数的所有表示形式中，如果数字为负数，则该位将设置为 1。

除了针对 0 的直接测试之外，没有任何测试可以区分零和正数。

要测试负数，您可以使用

#define IS_NEGATIVE(x) ((x) & (1U << ((sizeof(x)*CHAR_BIT)-1)))

Answer 15

假设您的数字是 a=10（正数）。如果您移动 a a 次，则结果为零。

即：

10>>10 == 0

因此您可以检查数字是否为正数，但如果a=-10（负数）：

-10>>-10 == -1

因此您可以将它们组合在if中：

if(!(a>>a))
   print number is positive
else 
   print no. is negative 

Answer 16

#include<stdio.h>
int checksign(int n)
{
    return (n >= 0 && (n & (1<<32-1)) >=0); 
}
void main()
{
  int num = 11;
  if(checksign(num))
    {
      printf("Unsigned number"); 
    }
  else
    {
      printf("signed Number");
    }
}

Answer 17

没有 if：

string pole[2] = {"+", "-"};
long long x;
while (true){
    cin >> x;
    cout << pole[x/-((x*(-1))-1)] << "\n\n";
} 

（不适用于 0）

Answer 18

if(n & (1<<31)) 
{
  printf("Negative number");
}
else{
  printf("positive number");
 }

它检查第 n 个数字的最高有效位，然后 &如果值为 1（为 true 则该数字为负数），则对其进行操作，否则为正数