당신은 어떻게 설정하고 명확하고,전환 싱글 비트?
https://stackoverflow.com/questions/47981
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
당신은 어떻게 설정하고 명확하고,전환트에서는 C/C++?
해결책
설정 비트
사용 비트 OR 연산자(|)를 설정하는 비트입니다.
number |= 1UL << n;
을 설정하는 nth 트 number. n 해야로 하려는 경우 설정 1세인트 비트에까지 n-1, 하려는 경우 설정 n번째 비트입니다.
사 1ULL 는 경우 number 보다 넓 unsigned long;의 촉진 1UL << n 일어나지 않는 이후까지 평가 1UL << n 그것은 어디로 정의되지 않은 행동을 변화에 의해 이상의 너비 long.적용하면 나머지는 모두의 예입니다.
지금
사용하는 비트 or 연산자(& 용)명확한 비트.
number &= ~(1UL << n);
는 것입 취소 nth 트 number.을 반전해야합 비트 문자열에는 비트 or 연산자(~음)하고 있습니다.
전환트
XOR 연산자(^)할 수 있 전환하는 데 사용됩니다.
number ^= 1UL << n;
는 것입니다 전환 nth 트 number.
검사 조
을 요구하지 않았지만,그 수도뿐만 아니라 추가합니다.
을 확인 비트 숫자를 이동 n 오른쪽으로,다음 비트와 it:
bit = (number >> n) & 1U;
는 값의 nth 트 number 로 변수 bit.
변경 nth 트 x
설정 n번째 비트 중 하나에 1 나 0 달성될 수 있으로 다음에는 2 개의 보충 C++구현:
number ^= (-x ^ number) & (1UL << n);
트 n 이 설정될 경우 x 가 1, 과하는 경우 삭제 x 가 0.는 경우 x 는 다른 값을 얻을 쓰레기입니다. x = !!x 이 booleanize0 또는 1.
이는 독립적의 2 의 보 부정 행위(가 -1 은 모든 비트를 설정에 달리 1 의 보거나 로그인/크기는 C++구현),사용 부호 부정이다.
number ^= (-(unsigned long)x ^ number) & (1UL << n);
나
unsigned long newbit = !!x; // Also booleanize to force 0 or 1
number ^= (-newbit ^ number) & (1UL << n);
그것은 일반적으로 좋은 아이디어를 부호 없는 형식을 사용하는을 위한 휴대용 비트입니다.
나
number = (number & ~(1UL << n)) | (x << n);
(number & ~(1UL << n)) 입 취소 n번째 비트와 (x << n) 를 설정합니다 nth 트 x.
그것도 일반적으로 좋은 생각하지 않을 복사/붙여넣기 코드에서는 일반 및 그렇게 많은 사람들이 사용하는 전처리기 매크로(like 커뮤니티 wiki 더운 다)또는 어떤 종류의 캡슐화합니다.
다른 팁
표준 C++라이브러리 사용: std::bitset<N>.
나 Boost 버 boost::dynamic_bitset.
할 필요가 없 자신의 롤:
#include <bitset>
#include <iostream>
int main()
{
std::bitset<5> x;
x[1] = 1;
x[2] = 0;
// Note x[0-4] valid
std::cout << x << std::endl;
}
[Alpha:] > ./a.out
00010
화 버전을 할 수 있습 런타임즈 bitset 과 비교 표준 라이브러리 컴파일 타임즈 bitset.
다른 옵션은 사용하는 비트 필드:
struct bits {
unsigned int a:1;
unsigned int b:1;
unsigned int c:1;
};
struct bits mybits;
정의는 3 비트 필드(실제로 그것은 세 1-bit felds).조금 작업이트(하)더 간단하다:
을 설정하거나 명확한 비트:
mybits.b = 1;
mybits.c = 0;
전환하는 비트:
mybits.a = !mybits.a;
mybits.b = ~mybits.b;
mybits.c ^= 1; /* all work */
검사 조금:
if (mybits.c) //if mybits.c is non zero the next line below will execute
이 작품으로 크기가 고정된 비트 필드가 있습니다.그렇지 않으면 당신은 리조트를 비트-만지작 기술에서 설명 이전 게시물이 있습니다.
내가 사용하는 매크로 에 정의된 헤더 파일을 처리하는 비트를 설정하고 분명하다:
/* a=target variable, b=bit number to act upon 0-n */
#define BIT_SET(a,b) ((a) |= (1ULL<<(b)))
#define BIT_CLEAR(a,b) ((a) &= ~(1ULL<<(b)))
#define BIT_FLIP(a,b) ((a) ^= (1ULL<<(b)))
#define BIT_CHECK(a,b) (!!((a) & (1ULL<<(b)))) // '!!' to make sure this returns 0 or 1
/* x=target variable, y=mask */
#define BITMASK_SET(x,y) ((x) |= (y))
#define BITMASK_CLEAR(x,y) ((x) &= (~(y)))
#define BITMASK_FLIP(x,y) ((x) ^= (y))
#define BITMASK_CHECK_ALL(x,y) (((x) & (y)) == (y)) // warning: evaluates y twice
#define BITMASK_CHECK_ANY(x,y) ((x) & (y))
그것은 때로는 가치 사용 enum 하기 이름 이 비트는 다음과 같습니다.
enum ThingFlags = {
ThingMask = 0x0000,
ThingFlag0 = 1 << 0,
ThingFlag1 = 1 << 1,
ThingError = 1 << 8,
}
다음 사용 이름 니다.I.e.쓰
thingstate |= ThingFlag1;
thingstate &= ~ThingFlag0;
if (thing & ThingError) {...}
을 설정하고,명확하고 테스트합니다.이 방법은 당신이 숨기는 마법의 숫자의 나머지 부분에서 당신의 코드입니다.
다른 것보다는 나을 보증하 제레미의 솔루션입니다.
서 snip-c.zip's bitops.h:
/*
** Bit set, clear, and test operations
**
** public domain snippet by Bob Stout
*/
typedef enum {ERROR = -1, FALSE, TRUE} LOGICAL;
#define BOOL(x) (!(!(x)))
#define BitSet(arg,posn) ((arg) | (1L << (posn)))
#define BitClr(arg,posn) ((arg) & ~(1L << (posn)))
#define BitTst(arg,posn) BOOL((arg) & (1L << (posn)))
#define BitFlp(arg,posn) ((arg) ^ (1L << (posn)))
OK,자 분석하는 것을...
일반적인 표현을 것 같다는 데 문제가와에서 이러한 모든 이다"(1L << (posn))".모든 이것은 마스크를 생성하는 단일 비 고서 작동하는 어떤 정수 입력.는"posn"인자를 지정 위치가 어디에 당신이 원하는 비트입니다.는 경우 posn==0,다음이 표현됩 평가:
0000 0000 0000 0000 0000 0000 0000 0001 binary.
는 경우 posn==8,그것을 평가하기:
0000 0000 0000 0000 0000 0001 0000 0000 binary.
다시 말해서,그것은 단순히 필드를 만듭 0 1 에서 지정 위치입니다.만 까다로운 부분에서 BitClr()매크로 우리가 필요트 싱글 0 비트 필드에서 1 습니다.이를 위해서 사용하는 1 의 보완 같은 식으로 표시하여 물결표(~)연산자입니다.
면 마스크가 생성에 적용되는 인수 그냥 당신 을 사용하여 비트 and(&),또는(|)및 or(^)연산자입니다.부터 마스크 long 형식은 매크로는 작업에 단지뿐만 아니라자들의 짧은 s,int s, 또는 긴습니다.
결론은 이것은 일반적인 솔루션을의 전체 클래스 문제입니다.그것은,물론,가능한 한도에 적합한 다시 작성 해당하는 이들의 매크로 명시적인 마스크 값을 때마다 당신 해야 하지만,그것은 왜?기억,매크로 대체에서 발생합니다 처리기와 그래서 생성된 코드를 반영할 것이라는 사실 값 로 간주되는 일정한 컴파일러에 의해-즉그것은 단지 효율적으로 사용하기 일반화된 매크로로 바퀴를 재발견""모든 시간은 당신이해야 할 비 조작입니다.
의 열?여기에 몇 가지 테스트 코드 사용 와트 컴 C 전체와 최적화 를 사용한 경우와 사용하지 않 _cdecl 그래서 결과 분해 것으로 깨끗 가능:
----[테스트입니다.C]----------------------------------------------------------------
#define BOOL(x) (!(!(x)))
#define BitSet(arg,posn) ((arg) | (1L << (posn)))
#define BitClr(arg,posn) ((arg) & ~(1L << (posn)))
#define BitTst(arg,posn) BOOL((arg) & (1L << (posn)))
#define BitFlp(arg,posn) ((arg) ^ (1L << (posn)))
int bitmanip(int word)
{
word = BitSet(word, 2);
word = BitSet(word, 7);
word = BitClr(word, 3);
word = BitFlp(word, 9);
return word;
}
----[테스트입니다.한(분해) ]-----------------------------------------------
Module: C:\BINK\tst.c
Group: 'DGROUP' CONST,CONST2,_DATA,_BSS
Segment: _TEXT BYTE 00000008 bytes
0000 0c 84 bitmanip_ or al,84H ; set bits 2 and 7
0002 80 f4 02 xor ah,02H ; flip bit 9 of EAX (bit 1 of AH)
0005 24 f7 and al,0f7H
0007 c3 ret
No disassembly errors
----[피 니스]-----------------------------------------------------------------
사용하는 비트 or 연산자 & |
을 설정하는 마지막에 000b:
foo = foo | 001b
을 확인하는 마지막에 foo:
if ( foo & 001b ) ....
하는 명확한 마지막에 foo:
foo = foo & 110b
내가 사용하는 XXXb 니다.당신은 아마도 작업으로 육 표시에 따라 데이터 구조에서는 당신이 포장 비트입니다.
초보자를 위한요 조금 더 많은 예제:
예제:
value is 0x55;
bitnum : 3rd.
이 & 용을 확인 비트:
0101 0101
&
0000 1000
___________
0000 0000 (mean 0: False). It will work fine if the third bit is 1 (then the answer will be True)
Toggle 또는 플:
0101 0101
^
0000 1000
___________
0101 1101 (Flip the third bit without affecting other bits)
| 운영자:설정 비트
0101 0101
|
0000 1000
___________
0101 1101 (set the third bit without affecting other bits)
여기에 내 마음에 드는 비트 연산 매크로는 작품을 위해 어떤 유형의 서명이 없는 정수 배열에서 unsigned char 지 size_t (가장 큰 입력해야 하는 효율적인 작동하):
#define BITOP(a,b,op) \
((a)[(size_t)(b)/(8*sizeof *(a))] op ((size_t)1<<((size_t)(b)%(8*sizeof *(a)))))
를 설정하는 비트:
BITOP(array, bit, |=);
을 명확한 비트:
BITOP(array, bit, &=~);
전환하는 비트:
BITOP(array, bit, ^=);
을 테스트하는 비트:
if (BITOP(array, bit, &)) ...
etc.
비트 필드에 접근 다른 장점에서 임베디드 아레나도 있습니다.할 수 있을 정의하는 구조체지도에 직접 비트에 특정 하드웨어 등록.
struct HwRegister {
unsigned int errorFlag:1; // one-bit flag field
unsigned int Mode:3; // three-bit mode field
unsigned int StatusCode:4; // four-bit status code
};
struct HwRegister CR3342_AReg;
당신이 알고 있어야의 비트 포장기 위해-나는 그것 MSB 첫째,하지만 이 구현에 따라 달라집니다.또한지 확인하는 방법을 컴파일러의 처리기 필드에 횡단 바이트다.
할 수 있습니다 다음 읽기,쓰기,시험의 개인 값을 전하고 있습니다.
이 같은 태그"embedded"나는 가정용 마이크로 제어기.모든 위의 제안 유효 및 일(읽기-수정하기/쓰기,조합,구조체,etc.).
그러나 그 중에 한판의 오실로스코프-기반으로 디버깅을 수 있다는 것이 놀랍습니다 하는 이러한 방법에 상당한 오버헤드에 CPU 사이클에 비해 값을 쓰면 바로 마이크로의 PORTnSET/PORTnCLEAR 등록하는 진정한 차이가 있는 단단한 루프/고주파수 ISR 의 토글 핀입니다.
에 익숙하지 않은 사람들을 위해:내 예를 들어,마이크로 일반적인 핀-상태 레지스터 PORTn 반영하는 출력 핀,그렇게 PORTn|=BIT_TO_SET 결과에 읽기-수정을 등록합니다.그러나,PORTnSET/PORTnCLEAR 등록 가'1'의미하는 것"이 비트 1"(설정)또는"이 비트 영"(일반)그리고'0'"을 의미하는 남 핀다.".그래서,당신은 결국 두 가지 포트 주소를 따라 당신이 설정 또는 삭제 조(항상 편리하지 않습니다)하지만 많 빠르게 반응하고 작은 조립된 코드입니다.
더 일반적으로,임의의 크기에 비트맵:
#define BITS 8
#define BIT_SET( p, n) (p[(n)/BITS] |= (0x80>>((n)%BITS)))
#define BIT_CLEAR(p, n) (p[(n)/BITS] &= ~(0x80>>((n)%BITS)))
#define BIT_ISSET(p, n) (p[(n)/BITS] & (0x80>>((n)%BITS)))
체크아트에서는 임의의 위치에 있는 변수 임의의 유형:
#define bit_test(x, y) ( ( ((const char*)&(x))[(y)>>3] & 0x80 >> ((y)&0x07)) >> (7-((y)&0x07) ) )
샘플 사용:
int main(void)
{
unsigned char arr[8] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF };
for (int ix = 0; ix < 64; ++ix)
printf("bit %d is %d\n", ix, bit_test(arr, ix));
return 0;
}
Notes: 이것은 빠른 수 있도록 설계되었(주는 유연성이)그리고 비 가지가 많은.그 결과 효율적인 SPARC 기계 코드를 컴파일할 때 태양을 스튜디오 8 일;나 또한 그것을 테스트를 사용하여 MSVC++2008 년에 amd64.그것은 가능한 유사한 매크로를 설정하고 지우는 비트입니다.의 주요 차이점이 솔루션과 비교해 많은 사람들은 그것은 작품에 대한 어떤 위치에서 거의 모든 유형의 변수입니다.
이 프로그램을 변경하는 모든 데이터 비트 0 에서 1 또는 1:0:
{
unsigned int data = 0x000000F0;
int bitpos = 4;
int bitvalue = 1;
unsigned int bit = data;
bit = (bit>>bitpos)&0x00000001;
int invbitvalue = 0x00000001&(~bitvalue);
printf("%x\n",bit);
if (bitvalue == 0)
{
if (bit == 0)
printf("%x\n", data);
else
{
data = (data^(invbitvalue<<bitpos));
printf("%x\n", data);
}
}
else
{
if (bit == 1)
printf("elseif %x\n", data);
else
{
data = (data|(bitvalue<<bitpos));
printf("else %x\n", data);
}
}
}
하는 경우 많은 비 만지작할 수 있습 마스크를 사용하는 모든 일이 더 빠르다.다음과 같은 기능은 매우 빠르고 있는 여전히 유연한(그들은 조금 만지작거리에서 조금도 어떤 크기).
const unsigned char TQuickByteMask[8] =
{
0x01, 0x02, 0x04, 0x08,
0x10, 0x20, 0x40, 0x80,
};
/** Set bit in any sized bit mask.
*
* @return none
*
* @param bit - Bit number.
* @param bitmap - Pointer to bitmap.
*/
void TSetBit( short bit, unsigned char *bitmap)
{
short n, x;
x = bit / 8; // Index to byte.
n = bit % 8; // Specific bit in byte.
bitmap[x] |= TQuickByteMask[n]; // Set bit.
}
/** Reset bit in any sized mask.
*
* @return None
*
* @param bit - Bit number.
* @param bitmap - Pointer to bitmap.
*/
void TResetBit( short bit, unsigned char *bitmap)
{
short n, x;
x = bit / 8; // Index to byte.
n = bit % 8; // Specific bit in byte.
bitmap[x] &= (~TQuickByteMask[n]); // Reset bit.
}
/** Toggle bit in any sized bit mask.
*
* @return none
*
* @param bit - Bit number.
* @param bitmap - Pointer to bitmap.
*/
void TToggleBit( short bit, unsigned char *bitmap)
{
short n, x;
x = bit / 8; // Index to byte.
n = bit % 8; // Specific bit in byte.
bitmap[x] ^= TQuickByteMask[n]; // Toggle bit.
}
/** Checks specified bit.
*
* @return 1 if bit set else 0.
*
* @param bit - Bit number.
* @param bitmap - Pointer to bitmap.
*/
short TIsBitSet( short bit, const unsigned char *bitmap)
{
short n, x;
x = bit / 8; // Index to byte.
n = bit % 8; // Specific bit in byte.
// Test bit (logigal AND).
if (bitmap[x] & TQuickByteMask[n])
return 1;
return 0;
}
/** Checks specified bit.
*
* @return 1 if bit reset else 0.
*
* @param bit - Bit number.
* @param bitmap - Pointer to bitmap.
*/
short TIsBitReset( short bit, const unsigned char *bitmap)
{
return TIsBitSet(bit, bitmap) ^ 1;
}
/** Count number of bits set in a bitmap.
*
* @return Number of bits set.
*
* @param bitmap - Pointer to bitmap.
* @param size - Bitmap size (in bits).
*
* @note Not very efficient in terms of execution speed. If you are doing
* some computationally intense stuff you may need a more complex
* implementation which would be faster (especially for big bitmaps).
* See (http://graphics.stanford.edu/~seander/bithacks.html).
*/
int TCountBits( const unsigned char *bitmap, int size)
{
int i, count = 0;
for (i=0; i<size; i++)
if (TIsBitSet(i, bitmap))
count++;
return count;
}
참고,설정하는 비트 가'n'에서 16 비트 정수해 다음을 수행할 수 있습니다.
TSetBit( n, &my_int);
그것은 당신을 위해 하는 비트 숫자의 범위 내에서 조금도 당신을 전달합니다.참고 작은 endian 프로세서에서는 바이트 단어,dwords,qwords,etc., 지도 올바르게 서로 메모리에서(주된 이유는 작은 endian 프로세서는'더 나은'큰 것보다-endian processors,아,나는 느낌을 화염에 전쟁에 나오는...).
이것을 사용:
int ToggleNthBit ( unsigned char n, int num )
{
if(num & (1 << n))
num &= ~(1 << n);
else
num |= (1 << n);
return num;
}
확장 bitset 대답:
#include <iostream>
#include <bitset>
#include <string>
using namespace std;
int main() {
bitset<8> byte(std::string("10010011");
// Set Bit
byte.set(3); // 10010111
// Clear Bit
byte.reset(2); // 10010101
// Toggle Bit
byte.flip(7); // 00010101
cout << byte << endl;
return 0;
}
을 수행하려면 이 모든 작업과 프로그래밍에 리눅스 커널 다음을 사용하여 표준 Api 의 리눅스 커널입니다.
보 https://www.kernel.org/doc/htmldocs/kernel-api/ch02s03.html
set_bit Atomically set a bit in memory
clear_bit Clears a bit in memory
change_bit Toggle a bit in memory
test_and_set_bit Set a bit and return its old value
test_and_clear_bit Clear a bit and return its old value
test_and_change_bit Change a bit and return its old value
test_bit Determine whether a bit is set
참고:여기에는 전체 작업에서 일어나는 단일 단계입니다.그래서 이 모든 것 atomic 도 SMP 컴퓨터에서 및 유용 을 유지하는 일관성에 걸쳐 프로세서를 지원합니다.
Visual C2010 년,그리고 아마도 많은 다른 컴파일러,직접적인 지원을 조금 작업이 내장되어 있습니다.놀랍게도,이 작품도 sizeof() 운영자가 제대로 작동합니다.
bool IsGph[256], IsNotGph[256];
// Initialize boolean array to detect printable characters
for(i=0; i<sizeof(IsGph); i++) {
IsGph[i] = isgraph((unsigned char)i);
}
그래서,당신의 질문 IsGph[i] =1, 나 IsGph[i] =0 을 설정하고 지우기 bools 쉽습니다.
을 찾을 인쇄할 수 없는 문자:
// Initialize boolean array to detect UN-printable characters,
// then call function to toggle required bits true, while initializing a 2nd
// boolean array as the complement of the 1st.
for(i=0; i<sizeof(IsGph); i++) {
if(IsGph[i]) {
IsNotGph[i] = 0;
} else {
IsNotGph[i] = 1;
}
}
참고가"아무것도 특별한"이것에 대해 코드입니다.취급 같은 비트 정수-는 기술적으로,그것입니다.1 비트 정수 보유할 수 있는 2 값,그리고 2 값일 뿐입니다.
저는 한번 사용하면 이 방법을 찾 중복 대출을 기록,loan_number 었 ISAM 키를 사용하여 6 자리의 대출 숫자 인덱스로 조금의 배열입니다.게 빠른 후,8 개월 동안 입증하는 메인 프레임 시스템을 데이터로서 실제로 작동하지 않습니다.단순 조금의 배열하게 자신의 정확성이 매우 높은 대한 접근 검색에 대한 예입니다.
중 하나를 사용의 연산자로 정의 기.
를 설정하는 비트,사용 int x = x | 0x?; 가 ? 는 비트 위치에 바이너리 형태입니다.
여기에는 일부의 매크로를 사용:
SET_FLAG(Status, Flag) ((Status) |= (Flag))
CLEAR_FLAG(Status, Flag) ((Status) &= ~(Flag))
INVALID_FLAGS(ulFlags, ulAllowed) ((ulFlags) & ~(ulAllowed))
TEST_FLAGS(t,ulMask, ulBit) (((t)&(ulMask)) == (ulBit))
IS_FLAG_SET(t,ulMask) TEST_FLAGS(t,ulMask,ulMask)
IS_FLAG_CLEAR(t,ulMask) TEST_FLAGS(t,ulMask,0)
는 데 사용되는 변수
int value, pos;
치 데이터
pos-의 위치가 조금 우리가 관심을 설정,취소 또는 전환합니다.
설정 비트:
value = value | 1 << pos;
명확한 비트:
value = value & ~(1 << pos);
Toggle 트:
value = value ^ 1 << pos;
당신은 어떻게 설정하고 명확하고,전환 싱글 비트?
결하는 일반적인 코딩 함정하려고 하면 양식 마스크:
1 지 충분히 넓
무슨 문제가 일어날 때 number 은 넓은 종류 이외 1?
x 수은 너무 큰 변화 1 << x 선도 정의되지 않은 동작 (UB).는 경우에도 x 너무 좋 ~ 지 않을 수도 있 플립 충분한 가장 중요한 비트.
// assume 32 bit int/unsigned
unsigned long long number = foo();
unsigned x = 40;
number |= (1 << x); // UB
number ^= (1 << x); // UB
number &= ~(1 << x); // UB
x = 10;
number &= ~(1 << x); // Wrong mask, not wide enough
을 확실히 하는 1 은 충분히 넓은:
코드를 사용할 수 1ull 또 pedantically (uintmax_t)1 고 컴파일러 최적화 할 수 있습니다.
number |= (1ull << x);
number |= ((uintmax_t)1 << x);
또 무게 코딩/평가/관리 문제를 유지하는 캐스팅 correct and up-to-date.
number |= (type_of_number)1 << x;
또는 부드럽게 촉진 1 강제 적용하여 수학하는 작업이 적어도처럼 다양한 종류의 number.
number |= (number*0 + 1) << x;
으로 대부분과 함께 비트를 조작,최고의 작업 명 유형이 아닌 명 람
int set_nth_bit(int num, int n){
return (num | 1 << n);
}
int clear_nth_bit(int num, int n){
return (num & ~( 1 << n));
}
int toggle_nth_bit(int num, int n){
return num ^ (1 << n);
}
int check_nth_bit(int num, int n){
return num & (1 << n);
}
C++11 템플릿화 버전(에 넣어 header):
namespace bit {
template <typename T1, typename T2> inline void set (T1 &variable, T2 bit) {variable |= ((T1)1 << bit);}
template <typename T1, typename T2> inline void clear(T1 &variable, T2 bit) {variable &= ~((T1)1 << bit);}
template <typename T1, typename T2> inline void flip (T1 &variable, T2 bit) {variable ^= ((T1)1 << bit);}
template <typename T1, typename T2> inline bool test (T1 &variable, T2 bit) {return variable & ((T1)1 << bit);}
}
namespace bitmask {
template <typename T1, typename T2> inline void set (T1 &variable, T2 bits) {variable |= bits;}
template <typename T1, typename T2> inline void clear(T1 &variable, T2 bits) {variable &= ~bits;}
template <typename T1, typename T2> inline void flip (T1 &variable, T2 bits) {variable ^= bits;}
template <typename T1, typename T2> inline bool test_all(T1 &variable, T2 bits) {return ((variable & bits) == bits);}
template <typename T1, typename T2> inline bool test_any(T1 &variable, T2 bits) {return variable & bits;}
}
중 하나를 시도하고 이러한 기능에는 C 언어를 변경하는 n 비트:
char bitfield;
// Start at 0th position
void chang_n_bit(int n, int value)
{
bitfield = (bitfield | (1 << n)) & (~( (1 << n) ^ (value << n) ));
}
나
void chang_n_bit(int n, int value)
{
bitfield = (bitfield | (1 << n)) & ((value << n) | ((~0) ^ (1 << n)));
}
나
void chang_n_bit(int n, int value)
{
if(value)
bitfield |= 1 << n;
else
bitfield &= ~0 ^ (1 << n);
}
char get_n_bit(int n)
{
return (bitfield & (1 << n)) ? 1 : 0;
}
