unsigned long temp = 0;

for (int i = 0; i< 32; i++)
{
    // проверяешь установлен ли i-й бит в 1...
    if ((your_long & temp) >> i) == 1)
    {
        // какая то обработка...
    }

    //переходим к след биту
    temp = temp << 1;
}

int what_bit(unsigned long x)
{
  if(x==0) return -1; // no bits
  int c=0;
  while(!(x&1)) { x>>=1; ++c; }
  if(x!=1) return -2; // multiple bits
  return c;
}

#define bit(n) (1<<(n))

int what_bit(unsigned long x)
{
  if(x == 0) return -1;
  if((x & (x-1)) != 0) return -2; // выставлено более 1 бита

#define test(n) if(x == bit(n)) return n; else if(x < bit(n))

  // 0..31
  test(16)
    // 0..15
    test(8)
      // 0..7
      test(4)
        // 0..3
        test(2)
          // 0..1
          test(1)
            return 0;
          else
            return -3; // ошибка! так не бывает.
        else
          return 3;
      else
        // 4..6
        test(5)
          return 4;
        else
          return 6;
    else
      // 9..15
      test(12)
        // 9..11
        test(10)
          return 9;
        else
          return 11;
      else
        // 13..15
        test(14);
          return 13;
        else
          return 15;
  else
    // 17..31
    test(24)
      // 17..23
      test(20)
        // 17..19
        test(18)
          return 17;
        else
          return 19;
      else
        // 21..23
        test(22)
          return 21;
        else
          return 23;
    else
      // 25..31
      test(28)
        // 25..27
        test(26)
          return 25;
        else
          return 27;
      else
        // 29..31
        test(30)
          return 29;
        else
          return 31;

#undef test
}

ME>Я видел код (буквально пять строчек), который это делает без цикла за O(1). Вот только ссылку никак не могу найти

int what_bit(unsigned long x)
{
  if(x==0) return -1; // no bits
  if (x & (x-1)) return -2; // multiple bits

  return int(log(x)/log(2)); //  :shuffle: ;) 
}

char GetBitPos( long n )
{
   char pos = 0;
   if(n & 0xFFFF0000) pos = 16, n >>= 16;
   if(n & 0x0000FF00) pos += 8, n >>= 8;
   if(n & 0x000000F0) pos += 4, n >>= 4;
   if(n & 0x0000000C) pos += 2, n >>= 2;
   if(n & 0x00000002) pos += 1;
   return pos;
};

int BitPos(long n)
{
    __asm
    {
      mov eax, n
      bsf eax, eax
    }
}

UgN>char GetBitPos( long n )

char GetBitPos( lond tested, long n )

WC>(риторический вопрос) А не дожен ли прототип функции быть таким? :

char GetBitPos( lond tested, long n )

char GetBitPos(long tested, long n)
{
  long i;
  char pos;
  for(i = 0; i < tested, n != 0; i++)
  {
    __asm
    {
       bsf eax, n
       btr n, eax
       mov pos, al
    }
  }
  return i == tested ? pos : -1;
}

WC>Неверно. Например, GetBitPos(0xF,3) должен вернуть 2, а возвращает -1. Возможно, n и tested перепутаны местами, но GetBitPos(3,0xF) также возвращает -1.

char GetBitPos(long data, long n)
{
  int i;
  char pos;
  for(i = 0; i < n && data != 0; i++)
  {
    __asm
    {
       bsf eax, data
       btr data, eax
       mov pos, al
    }
  }
  return i == n ? pos : -1;
}

int what_bit (long number)
{
  float f1;
  int f2;

  _asm
  {
    fld1
    fild dword ptr [number]
    fyl2x
    fst dword ptr [f1]
    fistp word ptr [f2]
  }
  
  if (f1==f2) return f2
  
  return -1;
}

WC>Неверно. Например, GetBitPos(0xF,3) должен вернуть 2, а возвращает -1. Возможно, n и tested перепутаны местами, но GetBitPos(3,0xF) также возвращает -1.

DK>Извиняюсь...

DK>char GetBitPos(long data, long n)
DK>{
DK>  int i;
DK>  char pos;
DK>  for(i = 0; i < n && data != 0; i++)
DK>  {
DK>    __asm
DK>    {
DK>       bsf eax, data
DK>       btr data, eax
DK>       mov pos, al
DK>    }
DK>  }
DK>  return i == n ? pos : -1;
DK>}
DK>

char GetBitPos1(long data, long n)
{
    char i;
  char pos;
    __asm
    {
       mov ecx, n
m:
       bsf eax, data
       btr data, eax
       jz end
       mov pos, al
       loop m
end:
       cmp ecx, 0
       je m2
       mov pos, 0
m2:
    }
  
  return pos ;
}

#include "iostream.h"

//  ВАРИАНТ1
int GetBitPos( int arg, int n )
{
    //  Простой вариант. Сложность - n
    int pos = 0;
    int cnt;
    for( cnt =0; cnt<n && pos<32; pos++){
        cnt += (arg>>31) & 1;
        arg <<= 1;
    }
    if( cnt<n )
        return -1;
    else
        return pos;
}

//  ВАРИАНТ2
int GetBitPos2( unsigned int arg, int n )
{
    //  Базируется на алгоритме подсчета установленных битов в слове,
    //  было то ли в алгоритмах, то ли в этюднике
    unsigned int n1 = ((arg& 0xAAAAAAAA) >> 1 ) + (arg& 0x55555555);
    unsigned int n2 = ((n1 & 0xCCCCCCCC) >> 2 ) + (n1 & 0x33333333);
    unsigned int n3 = ((n2 & 0xF0F0F0F0) >> 4 ) + (n2 & 0x0F0F0F0F);
    unsigned int n4 = ((n3 & 0xFF00FF00) >> 8 ) + (n3 & 0x00FF00FF);
    unsigned int n5 = ((n4 & 0xFFFF0000) >> 16) + (n4 & 0x0000FFFF);

    //  n5 - общее кол-во установленных битов


    if (n5 < n)
        return -1;
    if (!n)
        return 0;
    
    //  Ищем спускаясь по двоичному дереву. Сложность - log(n)

    int pos;
    unsigned int mask = 0xFFFF0000;
    int leftHalf = (n4 & mask) >> 16;

    if ( n > leftHalf){            
        pos = 16;                   //  Вправо
        n -= leftHalf;
        mask >>= 16;
    }
    else{
        pos = 0;                    //  Влево
    }

    mask &= 0xFF00FF00;
    leftHalf = (n3 & mask) >> (32-pos-8);

    if ( n > leftHalf){            
        pos += 8;                   //  Вправо
        n -= leftHalf;
        mask >>= 8;
    }

    mask &= 0xF0F0F0F0;
    leftHalf = (n2 & mask) >> (32-pos-4);

    if ( n > leftHalf){            
        pos += 4;                   //  Вправо
        n -= leftHalf;
        mask >>= 4;
    }

    mask &= 0xCCCCCCCC;
    leftHalf = (n1 & mask) >> (32-pos-2);

    if ( n > leftHalf){            
        pos += 2;                   //  Вправо
        n -= leftHalf;
        mask >>= 2;
    }

    mask &= 0xAAAAAAAA;
    leftHalf = (arg & mask) >> (32-pos-1);

    if ( n > leftHalf){            
        pos += 1;                   //  Вправо
        n -= leftHalf;
        mask >>= 1;
    }
    return pos+1;
}

//  ТЕСТ
int main(int argc, char* argv[])
{
    printf("Hello World!\n");

    cout << GetBitPos ( 0, 0 ) << "\n";
    cout << GetBitPos ( 0xFF00FF00, 1 ) << "\n";
    cout << GetBitPos ( 0xFF00FF00, 3 ) << "\n";
    cout << GetBitPos ( 0xFF00FF00, 9 ) << "\n";
    cout << GetBitPos ( 0xFF00FF00, 20) << "\n";
    cout << GetBitPos2( 0, 0 ) << "\n";
    cout << GetBitPos2( 0xFF00FF00, 1 ) << "\n";
    cout << GetBitPos2( 0xFF00FF00, 3 ) << "\n";
    cout << GetBitPos2( 0xFF00FF00, 9 ) << "\n";
    cout << GetBitPos2( 0xFF00FF00, 20) << "\n";
    
    flush(cout);

    unsigned int i;
    int r=0;

    for(i=0;i<10000000;i++){
        r+=GetBitPos( i, i % 16);
    }

    cout << r << "\n";
    flush(cout);
    r = 0;

    for(i=0;i<10000000;i++){
        r+=GetBitPos2( i, i % 16);
    }

    cout << r << "\n";
    flush(cout);

    return 0;
}

Description
The dynamic_bitset class represents a set of bits. It provides accesses to the value of individual bits via an operator[] and provides all of the bitwise operators that one can apply to builtin integers, such as operator& and operator<<. The number of bits in the set is specified at runtime via a parameter to the constructor of the dynamic_bitset.

The dynamic_bitset class is nearly identical to the std::bitset class. The difference is that the size of the dynamic_bitset (the number of bits) is specified at run-time during the construction of a dynamic_bitset object, whereas the size of a std::bitset is specified at compile-time through an integer template parameter.

The main problem that dynamic_bitset is designed to solve is that of representing a subset of a finite set. Each bit represents whether an element of the finite set is in the subset or not. As such the bitwise operations of dynamic_bitset, such as operator& and operator|, correspond to set operations, such as intersection and union.

bt ax,5         ;проверить значение 5-го бита - переносит бит в cf
;
mov ax, 10
bts pole, ax     ; проверить и установить 10-й бит в pole

struct BITS
{
    unsigned b0:1;
    unsigned b1:1;
    unsigned b2:1;
    unsigned b3:1;
    unsigned b4:1;
    unsigned b5:1;
    unsigned b6:1;
    unsigned b7:1;
    unsigned b8:1;
    unsigned b9:1;
    unsigned b10:1;
    unsigned b11:1;
    unsigned b12:1;
    unsigned b13:1;
    unsigned b14:1;
    unsigned b15:1;
    unsigned b16:1;
    unsigned b17:1;
    unsigned b18:1;
    unsigned b19:1;
    unsigned b20:1;
    unsigned b21:1;
    unsigned b22:1;
    unsigned b23:1;
    unsigned b24:1;
    unsigned b25:1;
    unsigned b26:1;
    unsigned b27:1;
    unsigned b28:1;
    unsigned b29:1;
    unsigned b30:1;
    unsigned b31:1;
};

int main(int argc, char* argv[])
{
    long z = 8192;
    BITS* p = (BITS*)&z;
    return 0;
}

    if( p->b13 )
    {
        doSomeThing();
    }