Checking if bit is not set
When you write if(value & 4)
, C checks the result to be non-zero. Essentially, it means
if((value & 4) != 0) {
...
}
Therefore, if you would like to check that the bit is not set, compare the result for equality to zero:
if((value & 4) == 0) {
...
}
C/C++ check if one bit is set in, i.e. int variable
In C, if you want to hide bit manipulation, you can write a macro:
#define CHECK_BIT(var,pos) ((var) & (1<<(pos)))
and use it this way to check the nth bit from the right end:
CHECK_BIT(temp, n - 1)
In C++, you can use std::bitset.
Checking if a bit is set or not
sounds a bit like homework, but:
bool IsBitSet(byte b, int pos)
{
return (b & (1 << pos)) != 0;
}
pos 0 is least significant bit, pos 7 is most.
How to check if exactly one bit is set in an int?
So you want to know if a number is power of 2 or not? Well there is a famous algorithm for that, you can simply do,
check_bit(std::uint32_t bits)
{
return bits && !(bits & (bits-1));
}
Any power of 2 when subtracted by 1 is all 1s
. e.g,
4 - 1 = 3 (011)
8 - 1 = 7 (0111)
The bitwise and of any power of 2 and any number 1 less than it will give 0
. So we can verify if a number is power of 2 or not by using the expression, n&(n-1)
.
It will fail when n=0
, so we have to add an extra and
condition.
For finding the position of bit, you can do:
int findSetBit(std::uint32_t bits)
{
if (!(bits && !(bits & (bits-1))))
return 0;
return log2(bits) + 1;
}
Extra Stuffs
In gcc, you can use __builtin_popcount()
, to find the count of set bits in any number.
#include <iostream>
int main()
{
std::cout << __builtin_popcount (4) << "\n";
std::cout << __builtin_popcount (3) << "\n";
return 0;
}
Then check if count is equal to 1
or not.
Regarding count, there is another famous algorithm, Brian Kernighan’s Algorithm. Google it up, it finds count in log(n)
time.
How can I check that a bit is set (without bitwise operation)?
The 'bit' (actually any base) value of an indexed number index in a value val in base base can in general be calculated as
val = 1966;
index = 2;
base = 10;
alert (Math.floor(val/Math.pow(base,index)) % base);
result: 9
val = 44;
index = 3;
base = 2;
alert (Math.floor(val/Math.pow(base,index)) % base);
result: 1
(only 0
and 1
are possible here – the range will always be 0..base-1
).
The combination of Math.floor
(to coerce to an integer in Javascript) and Math.pow
is kind of iffy here. Even in integer range, Math.pow
may generate a floating point number slightly below the expected 'whole' number. Perhaps it is safer to always add a small constant:
alert (Math.floor(0.1+val/Math.pow(base,index)) % base);
Why is a bit-wise AND necessary to check if a bit is set?
(mask >> i)
cannot eliminate the higher bits.
For example, when mask = 5
(101
in binary) and i = 1
, the value of (mask >> i)
is 2
. This evaluated as true
, but the 2nd lowest bit is 0
, so you fail to check the bit correctly.
Therefore, & 1
is necessary to eliminate the higher bits and check one specified bit correctly.
Check if multiple bits are set or cleared
To check whether multiple bits are cleared, you'd typically use this somewhat more concise idiom:
if ((statusRegister & 0x00000102) == 0) {}
// or
if (!(statusRegister & 0x00000102)) {}
You could also check whether multiple bits are set with:
if ((statusRegister | ~0x00000102) == ~0) {}
// or
if (!(~statusRegister & 0x00000102)) {}
But the version in your question is much more common. ANDing with a bitmask is the simplest mental model and easiest to understand for your fellow programmers.
Flags - Check if bits are set and only those bits are set
Sometimes the simplest answer eludes you after having your mind wrapped in complicated things.
This is enough:
if(value == flag)
And if you need to check multiple flags:
if(value == (SOMEFLAG_1 | SOMEFLAG_4))
^ ^
important important
And don't forget to enclose the bitwise operations in parenthesis. The precedence is unexpected and without them value == SOMEFLAG_1
would be evaluated first.
And I guess this is a perfect time for preaching for enabling (and paying attention to) compiler warnings:
clang has a very helpful one -Wparentheses
which is included in -Wall
:
5 : :5:28: warning: | has lower precedence than ==; == will be
evaluated first [-Wparentheses]if(value == SOMEFLAG_1 | SOMEFLAG_4)
~~~~~~~~~~~~~~~~~~~~^
5 : :5:28: note: place parentheses around the '==' expression
to silence this warningif(value == SOMEFLAG_1 | SOMEFLAG_4)
^
( )
5 : :5:28: note: place parentheses around the | expression to
evaluate it firstif(value == SOMEFLAG_1 | SOMEFLAG_4)
^
( )
gcc has it also:
5 : :5:14: warning: suggest parentheses around comparison in
operand of '|' [-Wparentheses]if(value == SOMEFLAG_1 | SOMEFLAG_4)
~~~~~~^~~~~~~~~~~~~
Related Topics
Add Items to Columns in a Wpf Listview
Wpf: Binding a Contextmenu to an Mvvm Command
What Does "Where T:Class, New()" Mean
.Net Xml Serialization Gotchas
How to Implement a Never Ending Task. (Timers VS Task)
Deserializing into a List Without a Container Element in Xml
Abstract Classes VS Interfaces
Getting the Absolute Path of the Executable, Using C#
How to Connect to an .Mdf (Microsoft SQL Server Database File) in a Simple Web Project
How to Use a Reserved Keyword as an Identifier in My JSON Model Class
How to Decode a Unicode Character in a String
How to Connect to an Mdf Database File
How Big Is an Object Reference in .Net
The ':' Character, Hexadecimal Value 0X3A, Cannot Be Included in a Name
ASP.NET Core 2 API Post Objects Are Null
Creating Instance of Type Without Default Constructor in C# Using Reflection