Well if that is how you want to do it then you need to learn some shifting. I don't know how it would be better to do it.
You can shift bits
<< up
>> down
// left shift <<
int i=5;-------- //binary 101
print i<<2 ----- //equivalent to i*(2^2)
output: 20 ----- //binary 10100 <--notice it shifted two spots
// right shift >>
int i=5;-------- //binary 101
print i>>2 ----- //equivalent to i/(2^2)
output: 1 ------ //binary 1
--------------------------
makecol 24bits
111111111111111111111111 // 24 bits
the first eight are used by red -
red_mask=111111110000000000000000 //binary
the middle eight are used by green -
green_mask=000000001111111100000000 //binary
the last eight are used by blue -
blue_mask=000000000000000011111111
to get the value we & and shift.
To get the red or green values then we need to shift all eight values to the front. since blue is at the front, no shifting is required.
red =(color & red_mask)>>16
green=(color & green_mask)>>8
blue =(color & blue_mask)

example:
color=101010001010101111110111
color & red_mask
color ---- 101010001010101111110111
red_mask - 111111110000000000000000
-----------------------------------
result --- 101010000000000000000000
red = result>>16 = 10101000 = 168
color & green_mask
color ----- 101010001010101111110111
green_mask- 000000001111111100000000
------------------------------------
result ---- 000000001010101100000000
green = result>>8 = 10101011 = 171
color & blue_mask
color ---- 101010001010101111110111
blue_mask- 000000000000000011111111
-----------------------------------
result --- 000000000000000011110111
green = result = 11110111 = 247
color = 101010001010101111110111 = 168,171,247
------------------------------------
So for your variable, you need to design just exactly what bits do what. Find out the maximum value to determine that amount of bits required.
lets say that your max width and height are 800x600
800 will require 10 bits
600 is also require 10 bits
so far we already using 20 bits
so the first 10 could be the width
width_mask=11111111110000000000=
height_mask=00000000001111111111

int make_val(width,height)
{
return height+width<<10;
}
int get_width(int p)
{
return (p & width_mask)>>10;
}
int get_height(int p)
{
return (p & height_mask);
}

If you want one variable to house x,y,width,height than your variable will need 40bits. You could do it. int is only 32 bits. use long. long has 64 bits.
first 10 for width
second 10 for height
third 10 for x
fourth 10 for y
[ October 28, 2001: Message edited by: DanielH ]

binary isn't that hard to understand. Its just a bunch of 1's and 0'
the decimal value is just the sum of each bit multiplied time 2^(place of bit)
binary 1010 = 1*2^3 + 0*2^2 + 1*2^1 + 0*2^0 = 8+0+2+0 = 10
----------------------------
If you did decide to do it this way then your value would be determined as follows
//your masks
w 1111111111000000000000000000000000000000
h 0000000000111111111100000000000000000000
x 0000000000000000000011111111110000000000
y 0000000000000000000000000000001111111111
long get_value(int w,int h,int x,int y)
{
return y+x<<10+h<<20+w<<30;
}
Just make sure the values don't exceed 2^10 which is 1024.
[ October 28, 2001: Message edited by: DanielH ]

The problem I have with binary, is that I can't compute it quickly..
I work from right to left, and I think of it like this..
start at 1, and keep doubling..
1,2,4,8,16,32,64,128.....
changing 0010 to 2 is easy, but changing 10101011 to 171 takes a second.
Anyhoo..
One think I got very confused with when testing...........
I'm confused on the mask, and the '&' operator.. when extracting each value.
w = (value & width_mask)>>10;
The '&' operator is the 'bitwise AND' right?
Well, I don't know EXACTLY what that is
I hate to ask you guys to teach me parts of C, but I learned from example.. cuz I'm poor What does the '&' operator do?
Anyhoo, the last thing that got me confused was how exactly the masks should be used.
int height_mask=00000000001111111111;
DJGPP tells me it's too big, and there's gonna be some sort of overflow problem..
whereas if I store it as '1024', it's decimal equivalent, the values end up incorrect.
At first I thought the masks were just a visual aid Then again, remember, this probably relates to my lack of knowledge of the '&' operator
Thanks, this is helping me understand bit shifting.

Under I32LP32 compilers (all of them for the x86, save for the special AMD one), long is 32 bits wide. long long (or int64_t or __int64) is 64 bits wide.

quote:char, unsigned char, signed char 1 byte 8 bits
short, unsigned short 2 bytes 16 bits
int, unsigned int 4 bytes 32 bits
long, unsigned long 4 bytes 32 bits
float, 4 bytes 32 bits
double, 8 bytes 64 bits
long double, 8 bytes 64 bits
That's not quite right either.
In C/C++:
char is at least 1 byte.
short is the shortest type the machine can use, that is larger than char.
int is the size of general purpose registers in the machine.
long is the longest type the machine can handle.
As you can see, these are very loose definitions. If you need really precise bit counts, then #include <types.h> and use
int8_t, int16_t, int32_t, int64_t, and so on, which are garenteed to be at least as large as the number of bits they say they have (that can be larger if the machine doesn't support them).
float and double are the only standard ones (IEEE-754). long double is an extension of double, and isn't quite standard. It is 80-bits on the x86, but may not have to be.

DanielH: I have K&R C - the One True C reference.
Install TurboC on your computer and run your sizeof() program. Now do it under a compiler for your microwave oven's CPU.
Some machines don't support unsigned numbers at all. Some machines don't support signed numbers at all. Some machines have only 8 bit registers. Some machines have only 64 bit registers.
C/C++ != Java.
C does NOT have standard type sizes. End of story.

yeah, in case of computer programming you must make binary (and hex...) math/magic your friend...it can help out a lot in simplifying things.
by the way, you can input binary masks/numbers directly like hex and dec numbers, but with a "b" at the end!!
1100 = 0x44c = 10001001100b
0x1100 = 4352 = 10001...00b (too big to write out now)
1100b = 0xc = 12
so a mask for the first (lower) 8 bits would be:
11111111b or 0xff or 255 (>char, unsigned char) or -1 (signed char)...lot's of stuff to watch, but make dj delories hcalc your friend and after a while you'll even be able to make those calculations in the head(and that's what hex is for, binary is just too many digits to remember/have an overview, so learn at least how to convert binary numbers from 0..15 (a nibble) into hex (0..f) and you don't even need a calculator anymore)
however watch about your packed structs, because intel world is little endian, thus affecting the order bytes are stored in memory: just imagine they're mirrored.
for example the 32 bit int 0xaabbccdd
would be stored in memory(wich is counted in bytes=chars) like this:
offset value
0 dd
1 cc
2 bb
3 aa
if you read the whole int at once from memory, you wont notice, but if you try to read the 4 single chars or 2 shorts it consits of, be prepared to break your head and pay attention to this sceme, otherwise you encounter strange results (values swapped).

I think the C standard says something unhelpful like short is not longer than int, and int is not longer than long.

My microwave was a Microsoft one; it crashed when I put more than one thing at once in it.

To be somewhat more useful - in these days it's not usual to be so short of memory that you have to resort to such tricks. One thing that C provides is a bitfield data type. I've never used it but it could be the thing you're after.

Pete

If you're using limits.h and C++, you can get the maximum values of the different types on different systems. The ones DanielH posted are all the minimum sizes of those types except int, which is 2 bytes or greater depending on the system. Say, you can get the maximum value of an int like this:
code:
#include <limits>
#include <iostream>

int main()
{
cout << numeric_limits<int>::max();
}
Untested, but should work. I don't use limits.h much so I'm not sure.
I don't think this really has anything to do with what's actually being discussed, I just figured I'd throw it out there