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.