Thread: Binary distribution problem

A class really only consists of its member data, so there is no "bytes allocated for the bitset<> itself."
Nevertheless, as far as I can see, the standard does not guarantee what the size of bitset<N> should be, so it's up to the implementers.
As for the second question, first, do you know what possible types that exist in C++ and their respective sizes?

It probably rounds it to the nearest 32bit boundary. Something like:

Bytes = 4 * ( ( Bits + 31 ) / 32 );

Or:

Bytes = ( ( Bits + 31 ) & ~31 ) >> 3;

In GCC's library implementation, it it computed by the following macro:

Code:

#define _GLIBCXX_BITSET_WORDS(__n) \
  ((__n) / _GLIBCXX_BITSET_BITS_PER_WORD + \
   ((__n) % _GLIBCXX_BITSET_BITS_PER_WORD == 0 ? 0 : 1))

Where bits per words is set to (__CHAR_BIT__ * __SIZEOF_LONG__)

Why that is so, I have no idea.
The main class just has an array of _GLIBCXX_BITSET_WORDS(__n) 'words'.
Where __n is the template argument you pass.

Well, that's a horrible implementation.
In MSVC, it's:

Code:

template<size_t _Bits>
	class bitset
	{	// store fixed-length sequence of Boolean elements
public:
	typedef typename _If<_Bits <= 32, _Uint32t, _ULonglong>::type _Ty;
...
}

where _Uint32t = 32-bit type, _Ulonglong = 64-bit type (essentially, if Bits <= 32, _Ty is a typedef for a 32-bit type; otherwise a 64-bit type).

So the implementation has two choices: either use some existing fixed type to represent the storage which means it will be limited to the available sizes offered by the language, or it could use a char array to hold the bits for a possibly more flexible representation.

But think a little about how you'd implement it were it to use a char array. It might give you some insight.
And if it's not implemented as a char array, then why is, for example, the size not 5 if using 40 bits? It might also help if you're familiar with hardware since implementations tend to be done in certain ways in order to work more efficiently on hardware.

Originally Posted by manasij7479

In GCC's library implementation, it it computed by the following macro:

Code:

#define _GLIBCXX_BITSET_WORDS(__n) \
  ((__n) / _GLIBCXX_BITSET_BITS_PER_WORD + \
   ((__n) % _GLIBCXX_BITSET_BITS_PER_WORD == 0 ? 0 : 1))

Where bits per words is set to (__CHAR_BIT__ * __SIZEOF_LONG__)

Why that is so, I have no idea.
The main class just has an array of _GLIBCXX_BITSET_WORDS(__n) 'words'.
Where __n is the template argument you pass.

That macro looks like it gives you the minimum number of 32bit or 64bit units the template argument needs, so you would need to still multiply the number it returns by the sizeof(long) to get the byte count I believe. Which should scale to represent the system you are on.

Originally Posted by Densetsu

Don't the statements that define class sizeof() consume memory? So when the compilier intercepts the function, it has to reserve memory for sizeof(), along with the data inserted?

sizeof is a compile time operator, not a function.

Originally Posted by Densetsu

@Elysia, Don't the statements that define class sizeof() consume memory? So when the compilier intercepts the function, it has to reserve memory for sizeof(), along with the data inserted?

No, sizeof is a compile-time operator, which means that the compiler will evaluate that and replace with the number of bytes in the compiled executable. A constant. So in your executable, you will have some instructions that says "print n" where n is a number.

Originally Posted by laserlight

sizeof is a compile time operator, not a function.

So the new proposed standard change to make it both did not get accepted?

I thought the change was C++ but, maybe it is in C standard it was proposed.

Tim S.

I do not recall any proposal about making sizeof a function. Why would you do it anyway?
EDIT: Making sizeof able to behave like a function would break lots of existing code since it's often used in meta template programming.

Given that sizeof() doesn't even evaluate its operand, making it a function doesn't even make sense. There is a difference between evaluating an expression and computing what type or size the result of that expression will be.


It is actually a coincidence of language rules that "sizeof expr" and "sizeof(expr)" have the same meaning - and that because the expression "expr" and "(expr)" are both expressions which yield the same result (in terms of value, if the expression is evaluated, and type).

Personally, I'd be a tiny bit happier if people weren't allowed to believe sizeof() was a function. I've seen people make a huge number of mistakes because they believe that.