C function call produces different result than C++ function call - c++

Question

I have this C code:
#include <stdio.h>
#include <windows.h>
int main() {
int i;
while(1) {
for (i = 8; i <= 190; i++) {
if (GetAsyncKeyState(i) == -32767) // That number doesnt actually work, only works with -32768 (which checks to see if the key is pressed down)
printf("%c\n",i); // When using -32768, it prints the key if it is held down about 20 times
}
}
return 0;
}
so -32767 doesnt work in that C code, but I have this C++ code:
#include <iostream>
using namespace std;
#include <windows.h>
int main() {
char i;
while (1) {
for(i = 8; i <= 190; i++) {
if (GetAsyncKeyState(i) == -32767) // works as intended, prints the pressed key letter (doesnt have to be held down)
cout << i << endl;
}
}
return 0;
}
Which works with -32767. This is very confusing as both of these are being ran on the same computer with the same command: clang++ test.c
Output of C with -32768(pressing A):
A
A
A
A
A
A
A
A
A
A
A
output of C++ code with -32767:
A
B
C
D
E
F
G
H
Output of C code with -32767:
(Nothing)

Answer 1

According to the documentation of GetAsyncKeyState:
If the function succeeds, the return value specifies whether the key was pressed since the last call to GetAsyncKeyState, and whether the key is currently up or down. If the most significant bit is set, the key is down, and if the least significant bit is set, the key was pressed after the previous call to GetAsyncKeyState. However, you should not rely on this last behavior; for more information, see the Remarks.
This says that it is not reliable to treat -32768 differently to -32767. It also says nothing about all of the bits in between, but your code is assuming they are 1 bits without justification.
To be reliable, your code should only do the following tests on the return value:
>= 0 - key currently up, or info unavailable
< 0 - key currently down

Answer 2

Your code relies on implementation-defined behavior. It appears that your C compiler is using unsigned chars, while your C++ compiler uses signed ones. That is why the nested loop in C goes all the way to 190, while the same loop in C++ wraps around to zero upon reaching 128.
You can fix this by making the type of i an unsigned char in both implementations. You could also make i an int, and add a cast to char in the call of GetAsyncKeyState function.

Answer 3

See this topic:
http://www.cplusplus.com/forum/general/141404/
-32767 is actually 1000 0000 0000 0001 in binary, when you compare the returned value from GetAsyncKeyState(i), you're basically asking if only the left and right bits are on, but as it is said in the link above, the bits 1-14 may not always be zero.
A more proper expression would be like that:
if (GetAsyncKeyState(i) & -32767)
or maybe use a hex literal instead:
if (GetAsyncKeyState(i) & 0x8001)

Answer 4

Actually the reason why the C implementation didnt work was because I was manually executing ./a in the mingw32 terminal and for some reason it didn't print anything until after alot of keys have been pressed, so I just executed a.exe by double-clicking and it worked, this has been a very weird experience :/