Thread: Could someone explain this code for me please...

Well, both type WordByte and type int take up the same space in memory: 4 bytes. Go ahead and run printf() statements for sizeof(WordByte) and sizeof(int). They're the same. And I assume you know how a union works.

I don't see how you can assign 8 bits to it. Unless you mean set the first(from left or right) 8 bits to 1. A byte is 8 bits, you can't change that, and an int takes up 4 bytes, which is 32 bits. You can't change how much the int takes up, and you can't change how much a byte takes up. The only thing I can see it doing with bits is setting them, 8 in this case.
For example:
An unsigned int set with no value:
00000000000000000000000000000000 << those many bits would be reserved for the int when it is created. You can't make it only take up say 00000000, which you can't go lower than a byte(8 bits). So regardless of you're number, for example 2, in binary 10, only takes up 2 bits. But you can't just put 2 bits in memory you have to put the whole byte, which would give 8 bits, 6 leading zero's before the 10. And an int get 4 bytes, so you have 30 leading zero's to the 10. So what you're saying assigning 8 bits to it, you can't do that. The int is automatically assigned 4 bytes. Maybe it's setting bits?
00000000000000000000000011111111 or
11111111000000000000000000000000.
I doubt that's the case.
Edit: Also, with 8 bits per byte, a byte is already 8 bits, so that statement wouldn't be needed, so that's most likely not it. And the bits in the byte can only be 8, so you couldn't put anything else, so it'd be a useless statement, that's definately not it.

Edit 2: I ran a little test, I found out what it's doing. It actually does have something to do with bits and assigning it to the int. The way I was thinking was wrong. Well, right in terms, if you put a number less than 8 it still allocates 4 bytes. You said it was some compression you were looking at? Well, that's the compression. What it's doing with the ints, by saying :n, it's compressing it by saying, allocate the 4 bytes, but do not allow any bits after nth bit to be changed from 0. So by saying :8, you're only allowing the first 8 bits to be changed. But here's what it's doing: the struct holds the 4 ints. Take out the :8 and each int will take up 4 bytes, and call sizeof() on the struct, it'll be 16 bytes. Makes sense. But, the compression is in relation to the struct. By saying 8 bits for each int, it doesn't need to allocate a whole 4 bytes that you're not gonna use. So it allocates the struct as if it were and int itself, using only 4 bytes (call sizeof() on the struct with :8's in). And each 8 bits of the 4 bytes are reserved for the ints. So basically you have an int in memory. And instead of reading the int itself, you use bitwise operators to extract the bits, and use the first 8 as one number, then 2nd as another and so on. That's what it's doing by itself. Since you're saying only use 8 bits for this int, and 4 of them are doing that, it's saying why not just allocate one int and read each byte as a different number. So when you set a value to one of these ints, it'll only change it's 8 bits in the int. So if you give a value like that will take more than 8 bits, it'll only set what it can leaving the rest of the int untouched. Also, like I said before, a int is 4 bytes, you're nicely seperating each int into a byte, making it take only and int. However if you add another int in there, regardless of it you only give it 8 bits or more or less, it'll allocate a whole 'nother int and the struct will take up 8 bytes. Also with just the 4, if you give each 16 bits, the struct will take 8 bytes. Try it, use the sizeof() function on the struct and try different values. I know this must be confusing as I didn't explain very well, and I only know what I got from running tests, I'm sure there's more indepth details about it. But I do know for sure that it's saying you only want to use 8 bits for the variable, and since you're doing that for all, you don't need the unnecessary extra 3 bytes, so the struct allocates one int to save space and stores the 4 values in that one. So it's a kind of compression on the struct by limiting how many bits you want the variables to take. If you understand bit-level stuff more and about bytes, and how to use bitwise operators you'd understand it more. Here's an example program that could store 4 numbers in a single int.

Code:

#include <iostream>
#define UINT unsigned int
using namespace std;

int main() {
    UINT storage;
    storage |= 3411719529; // set some random bits to 1 and some to 0
    UINT val1 = storage & 255; // extract first 8 bits from the right
    UINT val2 = (storage & 65280) >> 8; // extract second set of 8 bits
    UINT val3 = (storage & 16711680) >> 16; // and so on..
    UINT val4 = (storage & 4278190080) >> 24; // bit shifts are to shift the 8 bits all the way
    // to the right to prevent any following zeroes from increasing the value
    cout<<"Value 1: "<<val1<<endl; 
    cout<<"Value 2: "<<val2<<endl;
    cout<<"Value 3: "<<val3<<endl;
    cout<<"Value 4: "<<val4<<endl;
    cin.get(); // to keep program open
}

Run it and look at the values you get. Obviously extracting the data creates a whole 'nother 4 bytes to store it, but this is just an example, and those 4 bytes would be temporary anyway.

Calling all guru's! Answer thy plee! (this threads question, wth is : for)

I'd test by doing a simple:
unsigned int zero:8;

Then set it to say 5000, and bitshift it (and cout after each shift) to test the effects.. if I could even compile it:

7 C:\Projects\dfdsfsdf.cpp syntax error before `:' token

Lol Josh, I figured it out about half an hour before you did it just took me so long to explain it, look at my last post, it explains what is going on(pretty much what you said), but it also compresses the structure. And I gave an example program that does the same thing as the struct, but without the :8 thing.
The program I posted is pretty much doing what the struct is doing. But depending on how much the variable is reserved and how many variables, making it more flexible and easy.