Eagerly hope: "&" "|=" "^=" What are the practical meanings of these bit operators

aresgwl

Recently I was reading the original code, but I don’t understand the bitwise operators very clearly. Please help me explain the practical meaning of the bitwise operators "&", "|=" and "^=". It is best to give Thanks for the specific application example

julines

&is bitwise and
|=Bitwise OR first, then assignment.
^=Bitwise XOR first, then assignment.

killingme

In network programming, when you define a frame in communication with others, for example, the frame header is 0xFF, how can you define it as the frame header without bit manipulation?

zxc123456789

&is bitwise and 1&1==1 0&1==0 1&0==0 0&0==0
|Is bitwise OR 1|1==1 0|1==1 1|0==1 0|0==0
^is bitwise XOR 1^1==0 0^1==1 1^0==1 0^0==0
|=Bitwise OR first, then assignment.
^=Bitwise XOR first, then assignment.

clackhyf

If you don’t know what is the use of bitwise operations, or don’t know what bitwise operations are, you can read some books on electronic circuits or assembly. Bitwise operations are often required for hardware or communication;

aresgwl

BOOL CFileView::PreCreateWindow(CREATESTRUCT&cs)
  {
  if (!CListView::PreCreateWindow (cs))
  return FALSE;
   
          cs.style&= ~LVS_TYPEMASK;
          cs.style |= LVS_REPORT;
  return TRUE;
  }

Someone explained
cs.style&= ~LVS_TYPEMASK;//Get the window or control style LVS_TYPEMASK
cs.style |= LVS_REPORT; //Increase window or control style LVS_REPORT
What does this mean, can you explain it in detail, and at the same time:
bool
HeapTupleSatisfiesItself(HeapTupleHeader tuple, Buffer buffer)
{
if (!(tuple->t_infomask&HEAP_XMIN_COMMITTED))//tuple->t_infomask and HEAP_XMIN_COMMITTED
{
if (tuple->t_infomask&HEAP_XMIN_INVALID)
return false;

if (tuple->t_infomask&HEAP_MOVED_OFF)
{
TransactionId xvac = HeapTupleHeaderGetXvac(tuple);

if (TransactionIdIsCurrentTransactionId(xvac))
return false;
if (!TransactionIdIsInProgress(xvac))
{
if (TransactionIdDidCommit(xvac))
{
tuple->t_infomask |= HEAP_XMIN_INVALID;
SetBufferCommitInfoNeedsSave(buffer);
return false;
}
tuple->t_infomask |= HEAP_XMIN_COMMITTED;
SetBufferCommitInfoNeedsSave(buffer);
}
}
else if (tuple->t_infomask&HEAP_MOVED_IN)
{
TransactionId xvac = HeapTupleHeaderGetXvac(tuple);

if (!TransactionIdIsCurrentTransactionId(xvac))
{
if (TransactionIdIsInProgress(xvac))
return false;
if (TransactionIdDidCommit(xvac))
{
tuple->t_infomask |= HEAP_XMIN_COMMITTED;
SetBufferCommitInfoNeedsSave(buffer);
}
else
{
tuple->t_infomask |= HEAP_XMIN_INVALID;
SetBufferCommitInfoNeedsSave(buffer);
return false;
}
}
}
else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tuple)))
{
if (tuple->t_infomask&HEAP_XMAX_INVALID) /* xid invalid */
return true;

/* deleting subtransaction aborted */
if (TransactionIdDidAbort(HeapTupleHeaderGetXmax(tuple)))
{
tuple->t_infomask |= HEAP_XMAX_INVALID;
SetBufferCommitInfoNeedsSave(buffer);
return true;
}

Assert(TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmax(tuple)));

if (tuple->t_infomask&HEAP_MARKED_FOR_UPDATE)
return true;

return false;
}
else if (!TransactionIdDidCommit(HeapTupleHeaderGetXmin(tuple)))
{
if (TransactionIdDidAbort(HeapTupleHeaderGetXmin(tuple)))
{
tuple->t_infomask |= HEAP_XMIN_INVALID; //tuple->//
SetBufferCommitInfoNeedsSave(buffer);
}
return false;
}
else
{
tuple->t_infomask |= HEAP_XMIN_COMMITTED;
SetBufferCommitInfoNeedsSave(buffer);
}
}

/* by here, the inserting transaction has committed */

if (tuple->t_infomask&HEAP_XMAX_INVALID) /* xid invalid or aborted */
return true;

if (tuple->t_infomask&HEAP_XMAX_COMMITTED)
{
if (tuple->t_infomask&HEAP_MARKED_FOR_UPDATE)
return true;
return false; /* updated by other */
}

if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmax(tuple)))
{
if (tuple->t_infomask&HEAP_MARKED_FOR_UPDATE)
return true;
return false;
}

if (!TransactionIdDidCommit(HeapTupleHeaderGetXmax(tuple)))
{
if (TransactionIdDidAbort(HeapTupleHeaderGetXmax(tuple)))
{
tuple->t_infomask |= HEAP_XMAX_INVALID;
SetBufferCommitInfoNeedsSave(buffer);
}
return true;
}

/* xmax transaction committed */

if (tuple->t_infomask&HEAP_MARKED_FOR_UPDATE)
{
tuple->t_infomask |= HEAP_XMAX_INVALID;
SetBufferCommitInfoNeedsSave(buffer);
return true;
}

tuple->t_infomask |= HEAP_XMAX_COMMITTED;
SetBufferCommitInfoNeedsSave(buffer);
return false;
}

xietao405

cs.style&= ~LVS_TYPEMASK;//Get the window or control style LVS_TYPEMASK
cs.style |= LVS_REPORT; //Increase window or control style LVS_REPORT

Isn't the comment already clear?

Like LVS_REPORT are defined constants, for example 4, now cs.style is 2.

You can use a formula to explain
2|4=6
The above formula is converted to binary
010|100=110


In other words, cs.style is now 6
When the function is passed in, the function implementation will be split, the method can be&~ which is the inverse operation of the OR operation, to determine whether there is this option LVS_REPORT setting
The values ​​of these constants are all designed. Any two of the constants or operations have only unique values.
In the function implementation, you can judge based on these values

zfy010317

&and, two are 1 is 1, the others are 0
| Or, two 0 is 0, the other is 1
^ Or, two identical are 0, two different are 1
&= a&= b; is equal to a = a&b;
|= as above
^= as above

skill:
And, it can be used to mask out some bits, or to reserve some bits, with a number, the zero bit can be used to mask, and 1 bit can be used to keep the original state
0xffff&0x00ff == 0x00ff, mask the high bit 0xff00, reserve the low bit 0x00ff;
Or, it can be used to set some bits, because the original 1 bit will not be changed, only the zero bit can be changed, and multiple settings can be combined.
0x000f | 0x00f0 == 0x00ff;
Then you can use and to determine whether this bit is set
0x00ff&ox00f0 == 0x00f0;

o23rgovnr8243gr

Think of ! as a thing that inverts all the bits
0 -> 1
1 -> 0