这段代码中~0是什么意思？

Question

What's the meaning of ~0 in this code?
Can somebody analyze this code for me?

unsigned int Order(unsigned int maxPeriod = ~0) const
{
    Point r = *this;
    unsigned int n = 0;
    while( r.x_ != 0 && r.y_ != 0 )
    {
        ++n;
        r += *this;
        if ( n > maxPeriod ) break;
    }
    return n;
}

Answer 1

~0 is the bitwise complement of 0 , which is a number with all bits filled. For an unsigned 32-bit int, that's 0xffffffff . The exact number of f s will depend on the size of the value that you assign ~0 to.

Answer 2

It's the one complement, which inverts all bits.

 ~  0101 => 1010
 ~  0000 => 1111
 ~  1111 => 0000

Answer 3

As others have mentioned, the ~ operator performs bitwise complement. However, the result of performing the operation on a signed value is not defined by the standard.

In particular, the value of ~0 need not be -1 , which is probably the value intended. Setting the default argument to

unsigned int maxPeriod = -1

would make maxPeriod contain the highest possible value (signed to unsigned conversion is defined as an assignment modulo 2**n , where n is a characteristic number of the given unsigned type (the number of bits of representation)).

Also note that default arguments are not valid in C.

Answer 4

It's a binary complement function.

Basically it means flip each bit.

Answer 5

它是0的按位补码，在这个例子中，它是一个int，所有位都设置为1.如果sizeof（int）是4，那么数字是0xffffffff。

Answer 6

Basically, it's saying that maxPeriod has a default value of UINT_MAX. Rather than writing it as UINT_MAX, the author used his knowledge of complements to calculate the value.

If you want to make the code a bit more readable in the future, include

#include <limits>

and change the call to read

unsigned int     Order(unsigned int maxPeriod = UINT_MAX) const

Now to explain why ~0 is UINT_MAX. Since we are dealing with an int, in which 0 is represented with all zero bits (00000000). Adding one would give (00000001), adding one more would give (00000010), and one more would give (00000011). Finally one more addition would give (00000100) because the 1's carry.

For unsigned ints, if you repeat the process ad-infiniteum, eventually you have all one bits (11111111), and adding another one will overflow the buffer setting all the bits back to zero. This means that all one bits in an unsigned number is the maximum that data type (int in your case) can hold.

The "~" operation flips all bits from 0 to 1 or 1 to 0, flipping a zero integer (which has all zero bits) effectively gives you UINT_MAX. So he basically the previous coded opted to computer UINT_MAX instead of using the system defined copy located in #include <limits.h>

Answer 7

In the example it is probably an attempt to generate the UINT_MAX value. The technique is possibly flawed for reasons already stated.

The expression does however does have legitimate use to generate a bit mask with all bits set using a literal constant that is type-width independent; but that is not how it is being used in your example.

Answer 8

As others have said, ~ is the bitwise complement operator (sometimes also referred to as bitwise not). It's a unary operator which means that it takes a single input.

Bitwise operators treat the input as a bit pattern and perform their respective operations on each individual bit then return the resulting pattern. Applying the ~ operator to the bit pattern will negate each bit (each zero becomes a one, each one becomes a zero).

In the example you gave, the bit representation of the integer 0 is all zeros. Thus, ~0 will produce a bit pattern of all ones. Even though 0 is an int, it is the bit pattern ~0 that is assigned to maxPeriod (not the int value that would be represented by said bit pattern). Since maxPeriod is an unsigned int, it is assigned the unsigned int value represented by ~0 (a pattern of all ones), which is in fact the highest value that an unsigned int can store before wrapping around back to 0.