also ich hab dise code:

void bla ()
{
    if(GetAsyncKeyState('O'))
{
die funktion
}
}

so ruf ich sie auf :
[cpp]void aufrufen()
{
for(;; )
{
Bla();
...();
Sleep(30);
}
}

so jetzt noch mal die frage deutlicher :
ist es möglich, das wenn ich die taste o drücke, das er des dann so lange macht bis er ne ander taste gedrückt bekommt, z.B. ö also

ich hoffe ich war deutlich

ich hoffe ich war deutlich

Die Hoffnung stribt zuletzt

Also nein, warst du nicht.

bla wird von der schleife aufgerufen
---|---
die taste wurde nicht gedrückt die er bei GetAsyncKeyState hätte bekommen müssen
---|---
bla wird von der schleife aufgerufen
---|---
die taste wurde gedrückt also führt es jetzt das eine aus was ich unter GetAsyncKeyState gersetzt habe also des hier

if(GetAsyncKeyState('O'))
{
die funktion //  <------

---|---
bla wird von der schleife aufgerufen
---|---
taste wiud nicght mehr gedrückt, er führt aber trotzdem die fuktion aus weil sie beim vorhärigen mahle gedrückt worden war
---|---
bla wird von der schleife aufgerufen
---|---
eine andere taste wurde gesdrückt sagen wir die btaste P
---|---
jetzt wird des in Bla nicht mehr ausgeführt, weil die taste p gesrückt wurde

... usw

dass sollte aber deutlich sein oder

Du brauchst eine Variable (global, oder besser als Member einer Klasse) in der du abspeicherst welche Taste zuletzt gedrückt war. Oder welche Funktion beim nächsten Aufruf von bla() ausgeführt werden soll.

int whatToDo = 0;

void bla()
{
    if (GetAsynkKeyState(...)...)
        whatToDo = 1;
    else if (GetAsynkKeyState(...)...)
        whatToDo = 2;

    if (whatToDo == 1)
        do1();
    else if (whatToDo == 2)
        do2();
    else
        doElse();
}

Natürlich kann man statt der Variable auch Funktionszeiger oder tr1::function nehmen, aber das ist denke ich mal die einfachste Lösung.

if(bla==true)

das hab ch darein gesetzt
und so ruf ichs auf:

if (GetAsyncKeyState('M')&1)
{
bla = bla==false;
}

-> bla = !bla; ;o)

if (GetAsyncKeyState('M')&1)

würd ich im übrigen in ne extra Funktion packen - ich mag API-Fkt eh nie direkt im Code nutzen - falls man irgendwann doch mal denkt, dass man das ganze evtl auch mal auf ne andere plattform portieren könnte, sucht man dann ewig, wo überall man die api-fkt aufruft...

/*../windows/key_codes.h*/
#define NOMINMAX
/*noch mehr böse winapi-makros durch schalter deaktiveren*/
#include "windows.h"
#undef NOMINMAX
#undef IN
#undef OUT
/*noch mehr böse winapi-makros deaktiveren, für die es keine schalter gibt*/

enum key_codes
{
  A = 'A', /*...*/
  NUM_PAD_0 = ...,
...
};

namespace detail
{
  bool key_pressed(key_codes key)
  {
    return 0x01&GetAsyncKeyState(int(key));
  }
  bool key_pressed_since_last_call(key_codes key)
  {
    return 0x02&GetAsyncKeyState(int(key));
  }
}

/*../posix/key_codes.h*/
enum key_codes
{
  /*...*/
};

/*...*/

#if defined(_WIN32) || defined(_WIN64)
#  include "windows/key_codes.h"
#elif defined(kein_plan_worauf_man_hier_testet)
#  include "posix/key_codes.h"
#else
#  error not supported platform
#endif

bool key_pressed(key_codes key)
{
  return detail::key_pressed(key);
}
bool key_pressed_since_last_call(key_codes key)
{
  return detail::key_pressed_since_last_call(key);
}

so in etwa sollte es funktionieren - und die paar zeilen mehr sollten nicht weiter schlimm sein - ok, die enums werden ein wenig schreibarbeit sein - aber ansonsten sollte es sich vom aufwand her nichts nehmen.

bb

PS: Windows Key-Codes gibts hier:
http://msdn.microsoft.com/en-us/library/dd375731%28v=VS.85%29.aspx