I would precompute the number of set bits for every 8-bit value and store it in a 256-byte array:

char a[256] = {0};
for (int i = 1; i < 256; ++i)
a[i] = a[i/2] + i%2;

int n = 0;
for (; len > 0, --len)
n += a[*buf++];
return n;

It is also possible to precompute more values at the expense of higher memory usage.
 

what if we want to count numner of 0's? I am new to computer science and I was wondering if the same algorithm will work for 0's or not. (please mention a book about counting various numbers in datastructures if possible)
 

Have you seen this:
http://graphics.stanford.edu/~seander/bithacks.html
 

Thanks a lot, that page made my night! Just submitted some corrections.
 

#define TRESULT long
BYTE f(TRESULT vect)
{
  TRESULT lululu;
  BYTE sum=0;
  for(lululu=1;lululu;lululu<<=1)
   if(vect&lululu)
    sum++;
  //for(;;)love(!); I don't have much memory, but my CPU is fast!
  return sum;
}
 

Thanks to everybody who commented. Indeed using a precomputed table is the fastet way. But Xet, you really want to use an static table man. For the database search results bit vector that is sparse, a word-wide check for zero words can speed up by a constant factor still.

But on the smart solutions, what I was looking for was a way that takes time proportional to the number of set bits in a word, not the number of bits in the word, and indeed Brian Kernighan's method does exactly that. Thanks to Owrdac for the BitHacks link. You can find it here.

Thanks for the anonymous love letter h.

And finally, my rather dull idea was: If you have two bit vectors A and B, then C=(A|B) and D=(A&B) are two new vectors such that n(A)+n(B) == n(C)+n(D) where n(X) is the number of set bits in X. Moreover, n(C) >= max(n(A), n(B)), and n(D) <= min(n(A), n(B)). So if you have cheap operations for bitwise or, bitwise and, check for all-zero, and check for all-one on vectors, we could use this algorithm: given vector X, if X is all-zero or all-one, return with the answer, otherwise break X into X1 and X2, boost the number of set bits towards all-one and all-zero, by replacing X1 and X2 with (X1|X2) and (X1&X2) and recurse. Apparently this is of no use in Turing-equivalent machines we have today, but maybe in some quantum mechanics computers in the future ;).