Question

There’s a common way to store multiple values in one variable, by using a bitmask. For example, if a user has read, write and execute privileges on an item, that can be converted to a single number by saying read = 4 (2^2), write = 2 (2^1), execute = 1 (2^0) and then add them together to get 7.

I use this technique in several web applications, where I’d usually store the variable into a field and give it a type of MEDIUMINT or whatever, depending on the number of different values.

What I’m interested in, is whether or not there is a practical limit to the number of values you can store like this? For example, if the number was over 64, you couldn’t use (64 bit) integers any more. If this was the case, what would you use? How would it affect your program logic (ie: could you still use bitwise comparisons)?

I know that once you start getting really large sets of values, a different method would be the optimal solution, but I’m interested in the boundaries of this method.

Answer 1

Off the top of my head, I’d write a set_bit and get_bit function that could take an array of bytes and a bit offset in the array, and use some bit-twiddling to set/get the appropriate bit in the array. Something like this (in C, but hopefully you get the idea):

// sets the n-th bit in |bytes|. num_bytes is the number of bytes in the array // result is 0 on success, non-zero on failure (offset out-of-bounds) int set_bit(char* bytes, unsigned long num_bytes, unsigned long offset) {   // make sure offset is valid   if(offset < 0 || offset > (num_bytes<<3)-1) { return -1; }    //set the right bit   bytes[offset >> 3] |= (1 << (offset & 0x7));    return 0; //success  }  //gets the n-th bit in |bytes|. num_bytes is the number of bytes in the array // returns (-1) on error, 0 if bit is 'off', positive number if 'on' int get_bit(char* bytes, unsigned long num_bytes, unsigned long offset) {   // make sure offset is valid   if(offset < 0 || offset > (num_bytes<<3)-1) { return -1; }    //get the right bit   return (bytes[offset >> 3] & (1 << (offset & 0x7)); }