Tek bir bit nas─▒l ayarlan─▒r, temizlenir ve de─či┼čtirilir?


Al─▒nan cevaba git


Biraz nas─▒l ayarlayabilir, temizleyebilir ve a├žabilirsiniz?


2432









Cevap say─▒s─▒n─▒ say: 27






Biraz ayarlama

| Bir bit ayarlamak i├žin bit y├Ân├╝nde VEYA operat├Âr├╝n├╝ ( ) kullan─▒n.

 number |= 1UL << n;
 

Bu n th bit ayarlayacakt─▒r number . n ayarlamak istedi─činiz takdirde, s─▒f─▒r olmal─▒d─▒r 1 st ─▒s─▒rd─▒ ve b├Âylece kadar ├╝zerinde n-1 , ayarlamak istedi─činiz takdirde n inci biti.

Kullan─▒m 1ULL durumunda number daha geni┼č oldu─ču unsigned long ; terfi, tan─▒mlanamayan davran─▒┼č─▒n nerenin geni┼čli─činden daha fazla kaymas─▒ gerekti─čini 1UL << n de─čerlendirene kadar olmaz . Ayn─▒s─▒ ├Ârneklerin geri kalan─▒ i├žin de ge├žerlidir. 1UL << n long

Biraz temizleme

Bir par├žay─▒ & silmek i├žin bit y├Ân├╝nde AND i┼člecini ( ) kullan─▒n.

 number &= ~(1UL << n);
 

Bu n th bit temizleyecektir number . Bit dizesini bit y├Ân├╝ne NOT operat├Âr├╝ ( ~ ), ard─▒ndan AND ile ters ├ževirmelisiniz .

Biraz ge├ži┼č yapmak

XOR operat├Âr├╝ ( ^ ), biraz ge├ži┼č yapmak i├žin kullan─▒labilir.

 number ^= 1UL << n;
 

Bu n th bit bitecek number .

Biraz kontrol

Bunu istemedin, ama ben de ekleyebilirim.

Biraz kontrol etmek i├žin n say─▒s─▒n─▒ sa─ča, sonra bit y├Ân├╝nde kayd─▒r─▒n VE:

 bit = (number >> n) & 1U;
 

Bu, n th bitinin de─čerini number de─či┼čkene koyacakt─▒r bit .

De─či┼čtirme N inci bit x

n Th bit bitini ayarlamak 1 veya 0 2'li bir tamamlay─▒c─▒ C ++ uygulamas─▒nda a┼ča─č─▒dakilerle sa─članabilir:

 number ^= (-x ^ number) & (1UL << n);
 

Bit n e─čer kurulacak x olan 1 ve e─čer temizlenir x oldu─čunu 0 . x Ba┼čka bir de─čeri varsa , ├ž├Âp al─▒rs─▒n─▒z. x = !!x 0 veya 1 olarak booleanize edecek.

Bunu, 2'nin tamamlay─▒c─▒ olumsuzlama davran─▒┼č─▒ndan ba─č─▒ms─▒z yapmak i├žin ( -1 t├╝m bitlerin, bir 1'in tamamlay─▒c─▒s─▒ndan veya i┼čaret / b├╝y├╝kl├╝k C ++ uygulamas─▒ndan farkl─▒ olarak ayarland─▒─č─▒), imzas─▒z olumsuzlama kullan─▒n.

 number ^= (-(unsigned long)x ^ number) & (1UL << n);
 

veya

 unsigned long newbit = !!x;    // Also booleanize to force 0 or 1
number ^= (-newbit ^ number) & (1UL << n);
 

Ta┼č─▒nabilir bit i┼čleme i├žin imzas─▒z t├╝rleri kullanmak genellikle iyi bir fikirdir.

veya

 number = (number & ~(1UL << n)) | (x << n);
 

(number & ~(1UL << n)) temizleyecektir n inci biti ve (x << n) ayarlayacakt─▒r n i├žin inci biti x .

Ayr─▒ca, genel olarak kodu kopyalamamak / yap─▒┼čt─▒rmamak genellikle iyi bir fikirdir ve pek ├žok ki┼či ├Âni┼člemci makrolar─▒ ( a┼ča─č─▒ do─čru topluluk wiki'nin yan─▒tlad─▒─č─▒ gibi ) veya bir t├╝r kaps├╝lleme kullan─▒r.


3411







Standart C ++ Kitapl─▒─č─▒ kullanma: std::bitset<N> .

Veya Boost versiyonu: boost::dynamic_bitset .

Kendinizinkini yuvarlaman─▒za gerek yok:

 #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
 

Y├╝kseltme s├╝r├╝m├╝, standart bir kitapl─▒k derleme zaman─▒ boyutlu bit setine k─▒yasla ├žal─▒┼čma zaman─▒ b├╝y├╝kl├╝─č├╝nde bir bit setine izin verir .


438







Di─čer se├ženek, bit alanlar─▒ kullanmakt─▒r:

 struct bits {
    unsigned int a:1;
    unsigned int b:1;
    unsigned int c:1;
};

struct bits mybits;
 

3 bitlik bir alan─▒ tan─▒mlar (asl─▒nda, ├╝├ž adet 1 bitlik ke├že). Bit i┼člemleri art─▒k biraz (haha) daha da basitle┼čiyor:

Biraz ayarlamak veya silmek i├žin:

 mybits.b = 1;
mybits.c = 0;
 

Biraz de─či┼čtirmek i├žin:

 mybits.a = !mybits.a;
mybits.b = ~mybits.b;
mybits.c ^= 1;  /* all work */
 

Biraz kontrol ediyorum:

 if (mybits.c)  //if mybits.c is non zero the next line below will execute
 

Bu sadece sabit boyutlu bit alanlar─▒yla ├žal─▒┼č─▒r. Aksi takdirde, ├Ânceki yaz─▒larda a├ž─▒klanan bit b├╝kme tekniklerine ba┼čvurman─▒z gerekir.


235







Bit k├╝mesi i┼člemek ve temizlemek i├žin bir ba┼čl─▒k dosyas─▒nda tan─▒mlanan makrolar─▒ kullan─▒n:

 /* 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))
 

163







Bir kullanarak bazen de─čer enum i├žin isim bitleri:

 enum ThingFlags = {
  ThingMask  = 0x0000,
  ThingFlag0 = 1 << 0,
  ThingFlag1 = 1 << 1,
  ThingError = 1 << 8,
}
 

Ard─▒ndan adlar─▒ daha sonra kullan─▒n . Yani yaz

 thingstate |= ThingFlag1;
thingstate &= ~ThingFlag0;
if (thing & ThingError) {...}
 

ayarlamak, silmek ve test etmek i├žin. Bu ┼čekilde, sihirli say─▒lar─▒ kodunuzun geri kalan k─▒sm─▒ndan gizlersiniz.

Bunun d─▒┼č─▒nda Jeremy'nin ├ž├Âz├╝m├╝n├╝ onayl─▒yorum.


111







G├Ânderen snip-c.zip 'ler 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)))
 

Tamam, hadi i┼čleri analiz edelim ...

T├╝m bunlarla ilgili problemlerinizin oldu─ču ortak ifade "(1L << (posn))" d─▒r. T├╝m bunlar tek biti a├ž─▒k olan ve herhangi bir tamsay─▒ tipinde ├žal─▒┼čacak bir maske olu┼čturmakt─▒r. "Posn" arg├╝man─▒ bit istedi─činiz yeri belirtir. Posn == 0 ise, bu ifade ┼ču ┼čekilde de─čerlendirilecektir:

 0000 0000 0000 0000 0000 0000 0000 0001 binary.
 

Pozn == 8 ise, ┼č├Âyle de─čerlendirir:

 0000 0000 0000 0000 0000 0001 0000 0000 binary.
 

Ba┼čka bir deyi┼čle, belirtilen konumda 1 ile 0 alan─▒n─▒ yarat─▒r. Tek zor k─▒s─▒m BitClr () makrosunda, burada 1'lik bir alanda tek bir 0 bit belirlememiz gerekiyor. Bu, 1'in tilde (~) operat├Âr├╝ taraf─▒ndan belirtilen ifadenin ayn─▒ ifadesini kullanarak ger├žekle┼čtirilir.

Maske olu┼čturulduktan sonra, sizin ├Ânerdi─činiz gibi, bitsel ve (&) veya (|) ve xor (^) operat├Ârlerini kullanarak arg├╝mana uygulan─▒r. Maske uzun bir t├╝r oldu─čundan, makrolar char karakterlerinde, short'lerde, int'lerde veya long'lerde oldu─ču gibi ├žal─▒┼č─▒r.

Sonu├ž olarak, bunun b├╝t├╝n bir problem s─▒n─▒f─▒na genel bir ├ž├Âz├╝m oldu─čudur. Elbette, her ihtiyac─▒n─▒z oldu─čunda bu makrolar─▒n herhangi birinin e┼čde─čerini a├ž─▒k maske de─čerleri ile yeniden yazmak elbette m├╝mk├╝n ve hatta uygun, ama neden yap─▒yorsunuz? Makro s├╝bstit├╝syonunun ├Ân i┼člemcide meydana geldi─čini ve bu nedenle ├╝retilen kodun, de─čerlerin derleyici taraf─▒ndan sabit say─▒ld─▒─č─▒ ger├že─čini yans─▒taca─č─▒n─▒ unutmay─▒n - yani, genelle┼čtirilmi┼č makrolar─▒ kullanmak i├žin "tekerle─či yeniden icat etmek" kadar etkilidir. bit manip├╝lasyon yapmak.

─░kna? ─░┼čte baz─▒ test kodlar─▒ - Watcom C'yi tam optimizasyonla ve _cdecl kullanmadan kulland─▒m, b├Âylece ortaya ├ž─▒kan s├Âkme m├╝mk├╝n oldu─ču kadar temiz olacak:

---- [TEST.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;
}
 

---- [TEST.OUT (demonte edilmi┼č)] ---------------------------------------- ---------

 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
 

---- [finis] ----------------------------------------------- ----------------------


44







Bitsel operat├Ârleri kullan─▒n: & |

Son biti ayarlamak i├žin 000b :

 foo = foo | 001b
 

Son bitini kontrol etmek i├žin foo :

 if ( foo & 001b ) ....
 

Son par├žay─▒ silmek i├žin foo :

 foo = foo & 110b
 

XXXb Netlik i├žin kullan─▒l─▒r . Paketlemekte oldu─čunuz veri yap─▒s─▒na ba─čl─▒ olarak muhtemelen HEX temsili ile ├žal─▒┼čacaks─▒n─▒z.


36







Yeni ba┼člayanlar i├žin bir ├Ârnekle biraz daha a├ž─▒klamak istiyorum:

├ľrnek:

 value is 0x55;
bitnum : 3rd.
 

& Operat├Âr denetim ikili kullan─▒l─▒r:

 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)
 

Ge├ži┼č veya ├çevir:

 0101 0101
^
0000 1000
___________
0101 1101 (Flip the third bit without affecting other bits)
 

| i┼čle├ž: biti ayarla

 0101 0101
|
0000 1000
___________
0101 1101 (set the third bit without affecting other bits)
 

31







─░┼čte gelen i┼čaretsiz tamsay─▒ dizisinin her t├╝rl├╝ i├žin ├žal─▒┼č─▒r sevdi─čim biraz aritmetik makro, var unsigned char etmek up size_t (ile i┼če verimli olmal─▒d─▒r b├╝y├╝k t├╝r├╝d├╝r):

 #define BITOP(a,b,op) \
 ((a)[(size_t)(b)/(8*sizeof *(a))] op ((size_t)1<<((size_t)(b)%(8*sizeof *(a)))))
 

Biraz ayarlamak i├žin:

 BITOP(array, bit, |=);
 

Biraz temizlemek i├žin:

 BITOP(array, bit, &=~);
 

Biraz de─či┼čtirmek i├žin:

 BITOP(array, bit, ^=);
 

Biraz test etmek i├žin:

 if (BITOP(array, bit, &)) ...
 

vb.


25


2010-07-13





Bu "g├Âm├╝l├╝" olarak etiketlendi─či i├žin bir mikrodenetleyici kulland─▒─č─▒n─▒z─▒ varsayaca─č─▒m. Yukar─▒daki ├Ânerilerin t├╝m├╝ ge├žerlidir ve ├žal─▒┼čmal─▒d─▒r (okuma-de─či┼čtirme-yazma, sendikalar, yap─▒lar vb.).

Bununla birlikte, bir osiloskop tabanl─▒ hata ay─▒klama i┼člemi s─▒ras─▒nda, bu y├Ântemlerin, mikroda bulunan PORTnSET / PORTnCLEAR yazma├žlar─▒na do─črudan bir de─čer yazmakla k─▒yasland─▒─č─▒nda CPU d├Âng├╝lerinde ├Ânemli bir ek y├╝ke sahip oldu─čunu g├Âr├╝nce ┼ča┼č─▒rd─▒m. frekansl─▒ ISR'nin ge├ži┼č pimleri.

Bilinmeyenler i├žin: ├ľrne─čimde, mikro, ├ž─▒k─▒┼č pinlerini yans─▒tan genel bir pin-durum kayd─▒na sahiptir, bu y├╝zden PORTn | = BIT_TO_SET yapmak, bu kay─▒t defterine okuma-de─či┼čtirme-yazma ile sonu├žlan─▒r. Bununla birlikte, PORTnSET / PORTnCLEAR kay─▒tlar─▒, "l├╝tfen bu biti 1 yap" (SET) veya "l├╝tfen bu biti s─▒f─▒r yap" (CLEAR) ve "pimi yaln─▒z b─▒rak" anlam─▒na gelen bir "0" anlam─▒na gelir. bu nedenle, bit'i ayarlaman─▒za veya silmenize (her zaman uygun de─čil) ancak ├žok daha h─▒zl─▒ bir tepki ve daha k├╝├ž├╝k bir montaj kodu olmas─▒na ba─čl─▒ olarak iki ba─člant─▒ noktas─▒ adresi bulunur .


24







Bitfield yakla┼č─▒m─▒n─▒n g├Âm├╝l├╝ arenada ba┼čka avantajlar─▒ vard─▒r. Belirli bir donan─▒m kayd─▒nda do─črudan bitlere e┼členen bir yap─▒ tan─▒mlayabilirsiniz.

 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;
 

Bit paketleme s─▒ras─▒n─▒n fark─▒nda olmal─▒s─▒n─▒z - ilk ├Ânce MSB oldu─čunu d├╝┼č├╝n├╝yorum, ancak bu uygulamaya ba─čl─▒ olabilir. Ayr─▒ca, derleyicinizin bayt s─▒n─▒rlar─▒n─▒ ge├žen alanlar─▒ nas─▒l i┼čledi─čini do─črulay─▒n.

Daha sonra ayr─▒ ayr─▒ de─čerleri okuyabilir, yazabilir, test edebilirsiniz.


23







─░ste─če ba─čl─▒ bir yerde de─či┼čken bir de─či┼čkende biraz kontrol edin:

 #define bit_test(x, y)  ( ( ((const char*)&(x))[(y)>>3] & 0x80 >> ((y)&0x07)) >> (7-((y)&0x07) ) )
 

├ľrnek kullan─▒m:

 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;
}
 

Notlar: Bu h─▒zl─▒ (esnekli─či g├Âz ├Ân├╝ne al─▒nd─▒─č─▒nda) ve dallanmayan ┼čekilde tasarlanm─▒┼čt─▒r. Sun Studio 8 derlendi─činde verimli SPARC makine kodu verir; Ayr─▒ca amd64'te MSVC ++ 2008 kullanarak test ettim. Bitleri ayarlamak ve silmek i├žin benzer makrolar yapmak m├╝mk├╝nd├╝r. Bu ├ž├Âz├╝m├╝n en ├Ânemli ├Âzelli─či, buradaki di─čerleriyle kar┼č─▒la┼čt─▒r─▒ld─▒─č─▒nda, hemen hemen her t├╝rl├╝ de─či┼čkende herhangi bir konum i├žin i┼če yaramas─▒d─▒r.


19







Daha genel, iste─če ba─čl─▒ boyutta bitmapler i├žin:

 #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)))
 

19


2009-06-13





Bu program herhangi bir veri bitini 0'dan 1'e veya 1'den 0'a de─či┼čtirmektir:

 {
    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);
        }
    }
}
 

13







├çok fazla twiddling yap─▒yorsan─▒z, her ┼čeyi daha h─▒zl─▒ hale getirecek maskeler kullanmak isteyebilirsiniz. A┼ča─č─▒daki i┼člevler ├žok h─▒zl─▒d─▒r ve hala esnektir (her boyuttaki bit haritalar─▒nda bit b├╝kmeye izin verirler).

 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;
}
 

Not, 'n' bitini 16 bit bir tamsay─▒ya ayarlamak i├žin ┼čunlar─▒ yap─▒n:

 TSetBit( n, &my_int);
 

Bit say─▒s─▒n─▒n, ge├žti─činiz bit e┼čleminin aral─▒─č─▒nda oldu─čundan emin olmak size kalm─▒┼čt─▒r. Unutmay─▒n ki baytlar, kelimeler, ┼čifreler, ┼čifreler, vb. Birbirlerini do─čru ┼čekilde e┼čleyen k├╝├ž├╝k endian i┼člemciler i├žin (k├╝├ž├╝k endian i┼člemcilerin b├╝y├╝k-endian i┼člemcilerden daha iyi olmalar─▒n─▒n ana nedeni, ah, bir alev sava┼č─▒n─▒n geldi─čini hissediyorum) ├╝zerine ...).


13







Bunu kullan:

 int ToggleNthBit ( unsigned char n, int num )
{
    if(num & (1 << n))
        num &= ~(1 << n);
    else
        num |= (1 << n);

    return num;
}
 

11


2009-04-11





bitset Cevab─▒ geni┼čletmek :

 #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;
}
 

10







B├╝t├╝n bu i┼člemleri Linux ├žekirde─činde C programlama ile yapmak istiyorsan─▒z Linux ├žekirde─činin standart API'lerini kullanman─▒z─▒ ├Âneririm.

Bkz. 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
 

Not: Burada t├╝m i┼člem tek bir ad─▒mda ger├žekle┼čir. Bu nedenle bunlar─▒n hepsinin SMP bilgisayarlarda bile atomik olmas─▒ garanti edilir ve i┼člemciler aras─▒nda tutarl─▒l─▒─č─▒ korumak i├žin faydal─▒d─▒r.


10







Visual C 2010 ve belki de bir├žok di─čer derleyiciler, yerle┼čik bit i┼člemleri i├žin do─črudan deste─če sahiptir. ┼×a┼č─▒rt─▒c─▒ bir ┼čekilde, bu ├žal─▒┼č─▒r, sizeof() operat├Âr bile d├╝zg├╝n ├žal─▒┼č─▒r.

 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);
}
 

├ľyleyse, sorunuza g├Âre IsGph[i] =1 , veya IsGph[i] =0 boollar─▒ d├╝zenlemeyi ve silmeyi kolayla┼čt─▒r─▒n.

Yazd─▒r─▒lamayan karakterleri bulmak i├žin:

 //  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;
    }
}
 

Bu kod hakk─▒nda "├Âzel" bir ┼čey olmad─▒─č─▒n─▒ unutmay─▒n. Birazc─▒k tamsay─▒ gibi davran─▒r - ki teknik olarak ├Âyle. 2 de─čeri ve sadece 2 de─čeri tutabilen 1 bit tam say─▒.

Bir keresinde bu yakla┼č─▒m─▒, 6 basamakl─▒ kredi numaras─▒n─▒ bit dizisine bir endeks olarak kullanan loan_number'─▒n ISAM anahtar─▒ oldu─ču yinelenen kredi kay─▒tlar─▒n─▒ bulmak i├žin kulland─▒m. ┼×iddetli bir ┼čekilde h─▒zl─▒ ve 8 ay sonra, verileri ald─▒─č─▒m─▒z ana bilgisayar sisteminin asl─▒nda hatal─▒ ├žal─▒┼čt─▒─č─▒n─▒ kan─▒tlad─▒. Bit dizilerinin basitli─či, ├Ârne─čin bir arama yakla┼č─▒m─▒na kar┼č─▒n, do─črulu─čuna ├žok g├╝venir.


9


2012-12-30





Burada tan─▒mlanan operat├Ârlerden birini kullan─▒n .

Bir biti ayarlamak i├žin, ikili bi├žimde bit konumunun kullan─▒ld─▒─č─▒ int x = x | 0x?; yerde kullan─▒l─▒r ? .


6







 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);
}
 

6







─░┼čte kulland─▒─č─▒m baz─▒ makrolar:

 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)
 

5







Kullan─▒lan de─či┼čken

 int value, pos;
 

de─čer - Veri
pos - ayarlamak, silmek veya de─či┼čtirmek istedi─čimiz bitin konumu.

Biraz ayarla:

 value = value | 1 << pos;
 

Biraz temizle:

 value = value & ~(1 << pos); 
 

Biraz ge├ži┼č yap:

 value = value ^ 1 << pos;
 

5







Tek bir bit nas─▒l ayarlan─▒r, temizlenir ve de─či┼čtirilir?

Maskeyi olu┼čturmaya ├žal─▒┼č─▒rken ortak bir kodlama tuza─č─▒n─▒ ele almak:
1 her zaman yeterince geni┼č de─čil

Daha number geni┼č bir tip oldu─čunda ne gibi problemler ya┼čan─▒yor 1 ? tan─▒ms─▒z davran─▒┼ča (UB) yol a├žan
x de─či┼čim i├žin ├žok b├╝y├╝k olabilir . ├çok iyi olmasa bile , en ├Ânemli bitleri yeterince ├ževiremezsiniz. 1 << x 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 sigortalamak i├žin yeterince geni┼č:

Kod, 1ull bilgisizce kullanabilir veya (uintmax_t)1 derleyiciyi derleyebilir.

 number |= (1ull << x);
number |= ((uintmax_t)1 << x);
 

Veya oyuncu se├žimi - oyuncu kadrosunun do─čru ve g├╝ncel kalmas─▒n─▒ sa─člayan kodlama / inceleme / bak─▒m sorunlar─▒ yapar.

 number |= (type_of_number)1 << x;
 

Veya nazik├že terfi 1 t├╝r├╝ kadar geni┼č bir matematik i┼člemi zorlayarak te┼čvik number .

 number |= (number*0 + 1) << x;
 

├ço─ču k├╝├ž├╝k manip├╝lasyonda oldu─ču gibi, imzal─▒ olanlarla de─čil imzas─▒z t├╝rlerle ├žal─▒┼čmak en iyisi


4


2017-09-27





C ++ 11 ┼čablonlu s├╝r├╝m├╝ (bir ba┼čl─▒─ča yerle┼čtirilmi┼č):

 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;}
}
 

3







─░lk ├Ânce birka├ž ┼čeyi varsayal─▒m,
num = 55 tamsay─▒ i┼člemleri ger├žekle┼čtirmek i├žin tamsay─▒ (k├╝me, alma, temizleme, ge├ži┼č).
n = 4 Bitsel i┼člemleri ger├žekle┼čtirmek i├žin 0 tabanl─▒ bit konumu.

Biraz almak nas─▒l?

  1. Almak i├žin nth num sa─č vardiya bit num , n zaman. Sonra bit y├Ân├╝nde ve & 1 ile ger├žekle┼čtirin .
 bit = (num >> n) & 1;
 

Nas─▒l ├žal─▒┼č─▒r?

        0011 0111 (55 in decimal)
    >>         4 (right shift 4 times)
-----------------
       0000 0011
     & 0000 0001 (1 in decimal)
-----------------
    => 0000 0001 (final result)
 

Biraz nas─▒l ayarlan─▒r?

  1. Belirli bir say─▒ biti ayarlamak i├žin. 1 n kez sola kayma . Ard─▒ndan bit y├Ân├╝nde VEYA | i┼člemi yap─▒n num .
 num |= (1 << n);    // Equivalent to; num = (1 << n) | num;
 

Nas─▒l ├žal─▒┼č─▒r?

        0000 0001 (1 in decimal)
    <<         4 (left shift 4 times)
-----------------
       0001 0000
     | 0011 0111 (55 in decimal)
-----------------
    => 0001 0000 (final result)
 

Biraz temizlemek nas─▒l?

  1. Sola kayma 1, n ├žarp─▒, yani 1 << n .
  2. Yukar─▒daki sonu├ž ile bitsel tamamlay─▒c─▒ ger├žekle┼čtirin. B├Âylece, ns bitin karars─▒z hale gelir ve bitin geri kalan─▒, yani ayarlan─▒r ~ (1 << n) .
  3. Son olarak, & yukar─▒daki sonu├ž ve ile bit y├Ân├╝nde AND i┼člemi ger├žekle┼čtirin num . Yukar─▒daki ├╝├ž ad─▒m birlikte yaz─▒labilir num & (~ (1 << n)) ;


Biraz temizlemek i├žin gereken ad─▒mlar

 num &= (~(1 << n));    // Equivalent to; num = num & (~(1 << n));
 

Nas─▒l ├žal─▒┼č─▒r?

        0000 0001 (1 in decimal)
    <<         4 (left shift 4 times)
-----------------
     ~ 0001 0000
-----------------
       1110 1111
     & 0011 0111 (55 in decimal)
-----------------
    => 0010 0111 (final result)
 

Biraz ge├ži┼č yapmak nas─▒l?

Biraz ge├ži┼č yapmak i├žin bitsel XOR ^ operat├Âr├╝n├╝ kullan─▒yoruz. Bitsel olarak XOR i┼čleci, her iki i┼členenin kar┼č─▒l─▒k gelen bitinin farkl─▒ olmas─▒ durumunda 1 olarak, aksi takdirde 0 olarak de─čerlendirilir.

Bu, biraz ge├ži┼č yapmak anlam─▒na gelir, ge├ži┼č yapmak istedi─činiz bit ve 1 ile XOR i┼člemini ger├žekle┼čtirmemiz gerekir.

 num ^= (1 << n);    // Equivalent to; num = num ^ (1 << n);
 

Nas─▒l ├žal─▒┼č─▒r?

  • Ge├žilecek bit 0 ise 0 ^ 1 => 1 ,.
  • Ge├žilecek bit 1 ise 1 ^ 1 => 0 ,.
        0000 0001 (1 in decimal)
    <<         4 (left shift 4 times)
-----------------
       0001 0000
     ^ 0011 0111 (55 in decimal)
-----------------
    => 0010 0111 (final result)
 

├ľnerilen okumalar - Bitwise operat├Âr al─▒┼čt─▒rmalar─▒


2







N bitini de─či┼čtirmek i├žin C dilinde bu i┼člevlerden birini deneyin:

 char bitfield;

// Start at 0th position

void chang_n_bit(int n, int value)
{
    bitfield = (bitfield | (1 << n)) & (~( (1 << n) ^ (value << n) ));
}
 

Veya

 void chang_n_bit(int n, int value)
{
    bitfield = (bitfield | (1 << n)) & ((value << n) | ((~0) ^ (1 << n)));
}
 

Veya

 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;
}
 

-2



─░lgili yay─▒nlar


MySQL Datetime s├╝tunu i├žin varsay─▒lan de─čeri nas─▒l belirlersiniz?

HttpClient iste─či i├žin ─░├žerik T├╝r├╝ ├╝stbilgisini nas─▒l belirlersiniz?

Windows'ta Git: Bir birle┼čtirme arac─▒ nas─▒l kurulur?

ASP.NET MVC uygulamas─▒nda ba┼člang─▒├ž ÔÇőÔÇősayfas─▒n─▒ hata ay─▒klama i├žin nas─▒l ayarlars─▒n─▒z?

Bir NSTextField i├žindeki metni nas─▒l ayarlad─▒n─▒z?

Android'de bir EditText i├žin maksimum karakter say─▒s─▒n─▒ nas─▒l belirlersiniz?

Yeni Ara├ž ├çubu─ču i├žin ba┼čl─▒k rengini nas─▒l belirlersiniz?

Reflut kullanarak, bir yap─▒ alan─▒n─▒n de─čerini nas─▒l belirlersiniz?

PHP'de HttpOnly ├žerezlerini nas─▒l kullan─▒rs─▒n─▒z

Pythonpathinizi ├Ânceden olu┼čturulmu┼č bir sanalenvde nas─▒l ayarl─▒yorsunuz?

Etiketle ilgili di─čer sorular [c++]


Python'da 'Enum'u nas─▒l temsil edebilirim?

JavaScript'te nesne kar┼č─▒la┼čt─▒rmas─▒ [kopya]

Git alt mod├╝l├╝ eklerken dal / etiket nas─▒l belirleyebilirim?

D├╝z ─░ngilizce olarak, ÔÇťgit resetÔÇŁ ne yapar?

Javadoc yorumunda ├žoklu sat─▒r kodu ├Ârne─či

SSH ortak anahtar─▒ma nas─▒l eri┼čirim?

─░ki ondal─▒k basama─ča say─▒ g├Âster

─░ki i├ž i├že listenin kesi┼čimini mi buluyorsunuz?

JQuery kullanarak bir form g├Ânderin

Nas─▒l Yap─▒l─▒r: C# komut sat─▒r─▒ y├╝r├╝tmek, STD OUT sonu├žlar─▒ almak