Macros work basically as 'find-and-replace' mechanism to simplify the code you have to write.

You have probably seen basic #define macros, for example:

#define A_NUMBER 0.016237523004432    

Following this macro definition, every time you write the text "A_NUMBER" (without quotes) in your code, the compiler program replaces it with the text "0.01623752300432" (without quotes) before it actually compiles the code. This 'find and replace' process is carried out by the preprocessor.

Macros can also take parameters. a bit like functions. For example

#define TIMES_BY_TWO(x) x*2     

so this...

int ANumber = 7;int MyNumber = TIMES_BY_TWO(ANumber);AnotherNumber=TIMES_BY_TWO(8);    

will become

int ANumber = 7;int MyNumber = ANumber*2;AnotherNumber=8*2;    

So, using your your macro

#define KEYDOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000 ? 1 : 0)    

this code:

if(KEYDOWN(VK_SPACE)){ //...}    

becomes this:

if(((GetAsyncKeyState(VK_SPACE) & 0x8000 ? 1 : 0)){ //...}    

As for bit testing, the way to test if a bit is set is to "bitwise and" (using the "&" operator) it with a mask consisting of the bit to want to test. E.g

// test bit 0 (use mask value 0x0001) which is // 0000000000000001 in binary)if( (Number & 0x0001) != 0 ){  // first (bottom) bit is set}// test bit 2 (use mask value 0x0004 which is // 0000000000000100 in binary)if( (Number & 0x0004) != 0 ){  // third bit is set}// test bit 15 (use mask value 0x8000, which is // 1000000000000000 in binary)if( (Number & 0x8000) != 0 ){  // top bit is set}// or as a short-hand representation of the same thing:// (since zero is interpreted as 'false')if( Number & 0x8000 ){  // top bit is set}    

which is exactly that the KEYDOWN macro is doing.

(The " ? 1 : 0 " part is not strictly necessary here. What it is doing is converting any true (nonzero) value to the value 1, which is pretty pointelss if you ask me unless you are comparing it with the value 1, and why you would want to do that I don't know...)

Hope that helps a little, though theres plenty more to learn about macros (several pitfalls and traps for the unwary... not all the code i have written here should be copied!)

[Edit - Fixed errors in example]




[edited by - Crazemanx on November 1, 2002 2:53:48 PM]

quote:
BYTE TestValue = KeyState & 0x8000;

now TestValue is the value of the high bit in KeyState. (?)

Yes, TestValue can be either 0x8000, if the high bit in KeyState is 1, or zero of the high bit in KeyState is zero.

quote:
if(GetAsyncKeyState(VK_RETURN) & 0x8000)
{
//return is down
}

Yeah, that''s exactly right. Sorry about the delay in replying.

(P.S. here''s a handy tip, make a macro like this:

#define BIT(n)  (1<<(n)) 

then BIT(15) is (1<<(15)) which is (in binary) 100000000000000 which is 0x8000, and so on.

There is no problem with efficiency, as the compiler will perform the left shift and compile the actual value into the code directly.)