int keyTemp[4] = {Key[KEY_INPUT_LEFT ],
                    Key[KEY_INPUT_RIGHT],
                    Key[KEY_INPUT_UP   ],
                    Key[KEY_INPUT_DOWN ],};

または

int keyTemp[4] = {KEY_INPUT_LEFT ,
                    KEY_INPUT_RIGHT,
                    KEY_INPUT_UP   ,
                    KEY_INPUT_DOWN ,};

int get_work(void)
{
  int i,j;
  int a = 0;

  // 止まる:0,上:1,右:2,下:3,左:4 に対応
  int state[5] = {0,
                  KEY_INPUT_UP,
                  KEY_INPUT_RIGHT,
                  KEY_INPUT_DOWN,
                  KEY_INPUT_LEFT,};

  // "上"から順に見ていく
  for(i = 1; i < 5; i++){
    if(Key[state[i]] != 0){// もし、見ようとするキーが押されているなら
      for(j = 1; j < 5; j++){
        // 自分以外のキーとの対応を見る
        if(i != j && ( Key[state[j]] == 0 || Key[state[i]] < Key[state[j]])){
          a = i;
          break;
        }
      }
      // もし、方向が決定しているならばループ終了
      if(a != 0) break;
    }
  }
  return a;
}

bool key_check(int key)
{
    if (Key[key] == 0)
        return false;

    bool ret = true;
    int chk[4] = {KEY_INPUT_UP, KEY_INPUT_DOWN, KEY_INPUT_RIGHT, KEY_INPUT_LEFT};
    for (int i = 0; i < 4; ++i)
        if (key != chk[i])
            ret &= (Key[chk[i]] == 0 || Key[key] < Key[chk[i]]);

    return ret;
}

int get_work(void)
{
    return    key_check(KEY_INPUT_UP)    ? 1 :
            key_check(KEY_INPUT_RIGHT) ? 2 :
            key_check(KEY_INPUT_DOWN)  ? 3 :
            key_check(KEY_INPUT_LEFT)  ? 4 : 0;
}

int a = 0, count = 0x7FFFFFFF;

if(Key[KEY_INPUT_UP] && Key[KEY_INPUT_UP] < count) a = 1, count = Key[KEY_INPUT_UP];
if(Key[KEY_INPUT_RIGHT] && Key[KEY_INPUT_RIGHT] < count) a = 2, count = Key[KEY_INPUT_RIGHT];
if(Key[KEY_INPUT_DOWN] && Key[KEY_INPUT_DOWN] < count) a = 3, count = Key[KEY_INPUT_DOWN];
if(Key[KEY_INPUT_LEFT] && Key[KEY_INPUT_LEFT] < count) a = 4, count = Key[KEY_INPUT_LEFT];

/*
    Windows XP sp3
    Visual Studio 2005 sp2
    Pentium4  2.26GHz
*/

#include <windows.h>
#include <iostream>
#include "Group.h"
using namespace std;

int main()
{
    LARGE_INTEGER Freq, Before, After;
    DWORD Time = 0;
    QueryPerformanceFrequency(&Freq);
    QueryPerformanceCounter(&Before);

    int n = 8;
    int i = 100000;

    while (i--)
    {
        if (n == (group::cluster, 0, 1, 2, 4, 8)){         
            ;
        }

        /*if( n == 0 || n == 1 || n == 2 || n == 4 || n == 8 ){ 
            ;
        }*/

        /*switch(n){                                              
            case 0: 
            case 1: 
            case 2: 
            case 4: 
            case 8: break;
            default: break;
        }*/
    }

    QueryPerformanceCounter(&After);
    Time = (DWORD)((After.QuadPart - Before.QuadPart) * 1000 / Freq.QuadPart);
    
    cout << Time << endl;

    cin.ignore();
    return 0;
}