What about multi dimensional vectors? Would the same advantage apply to a multi dimensional vector? The math gets a little more annoying if it is one dimensional going over a two dimensional screen.
std::vector<bool> image(false, 1920*1080);
image[x+y*1080] = true;
int is 32 bits.
char is 8 bits.
short is 16.
union
{
uint32_t color;
struct
{
uint32_t red : 8;
uint32_t green : 8;
uint32_t blue : 8;
uint32_t alpha : 8;
}
};
Actually char is 8bit in 99% of all environments, and from there it's char < short <= int (not perfectly sure about about where it's < and <=).
I recall reading somewhere that bool was longer than 1 bit, after googling it again I see that I was incorrect. Thanks.[/quote]
sizeof(bool) is generally equal to sizeof(int), due to the fact that most platforms are unable to access individual bits and have alignment restrictions on other datatypes. However std::vector<bool> is specifically designed to pack the elements as tightly as possible, and incurs an instruction overhead in doing so. If you need to set a lot of bits at once and are worried about performance, you might want to avoid using the subscript operator.
sizeof(bool) is generally equal to sizeof(int), due to the fact that most platforms are unable to access individual bits and have alignment restrictions on other datatypes. [/quote]
I think you are mistaking the padded size of the variable with the sizeof(variable).
sizeof(bool) is normally equal to sizeof(char), which is defined as 1 and is most commonly 8 bits. However, the compiler padding will often mean that an individual boolean value is allocated a word of space by itself. However, contiguous booleans will be tightly packed by most compilers.
[quote name='Dan Berliner' timestamp='1302137979' post='4795293']
What about multi dimensional vectors? Would the same advantage apply to a multi dimensional vector? The math gets a little more annoying if it is one dimensional going over a two dimensional screen.
std::vector<bool> image(false, 1920*1080);
image[x+y*1080] = true;
Which compiler did you use for that benchmark? Some compilers create extra code even in release mode when using standard library templates. For example some versions of MSVC will enable _SECURE_SCL in release, which can significantly slow things down.
template <int SIZE_IN_BITS>
class BitArray
{
char bytes[SIZE_IN_BITS/8];
public:
BitArray()
{
memset(bytes,0,sizeof(bytes));
}
void SetBit(int bit)
{
int index = bit / 8;
int offset = bit % 8;
char mask = 1 << offset;
bytes[index] |= mask;
}
void ClearBit(int bit)
{
int index = bit / 8;
int offset = bit % 8;
char mask = 0xFF & ~(1 << offset);
bytes[index] &= mask;
}
bool GetBit(int bit)
{
int index = bit / 8;
int offset = bit % 8;
char mask = 1 << offset;
return (bytes[index] & mask) == mask;
}
};
I've done that, but just to iterate though an 800*600 (480,000) element vector takes my computer about 570-590ms.
