ich habe einen einfache funktion und wollte wissen ob man diese irgendwie noch optimieren kann? z. B. durch bitshifts oder andere operationen.

Hier ist sie:

inline void getTilePositionInSurface (wchar_t value, int* x, int* y)
{
    if (!x || !y) return;

    if (value == L'0') { (*x) = 0; (*y) = 0; }
    if (value == L'1') { (*x) = 1; (*y) = 0; }
    if (value == L'2') { (*x) = 2; (*y) = 0; }
    if (value == L'3') { (*x) = 3; (*y) = 0; }
    if (value == L'4') { (*x) = 0; (*y) = 1; }
    if (value == L'5') { (*x) = 1; (*y) = 1; }
    if (value == L'6') { (*x) = 2; (*y) = 1; }
    if (value == L'7') { (*x) = 3; (*y) = 1; }
    if (value == L'8') { (*x) = 0; (*y) = 2; }
    if (value == L'9') { (*x) = 1; (*y) = 2; }
    if (value == L'A') { (*x) = 2; (*y) = 2; }
    if (value == L'B') { (*x) = 3; (*y) = 2; }
    if (value == L'C') { (*x) = 0; (*y) = 3; }
    if (value == L'D') { (*x) = 1; (*y) = 3; }
    if (value == L'E') { (*x) = 2; (*y) = 3; }
    if (value == L'F') { (*x) = 3; (*y) = 3; }
}

Danke im voraus

inline void getTilePositionInSurface (wchar_t value, int* x, int* y)
{
    if (!x || !y) return;

    if (value == L'0') { (*x) = 0; (*y) = 0; }
    else if (value == L'1') { (*x) = 1; (*y) = 0; }
    else if (value == L'2') { (*x) = 2; (*y) = 0; }
    else if (value == L'3') { (*x) = 3; (*y) = 0; }
    else if ....
}

Wozu int* ? Muss das sein? ansonstens kannste auch int& x, int& y verwenden. Dann kannste auch x=0 und y=0 schreiben.
Dann entfällt auch if (!x || !y) return;

wegen den pointern: wenn ich eine Funktion aufrufe möchte ich schon wissen, ob daten geändert werden von dem was ich übergebe. das mache ich überall bei solchen funktionen und hat mir schon oft beim fehlerfinden geholfen.

hmn ob das else was bringt?

Selbstverständlich.

hmn ob das else was bringt?

wegen den pointern: wenn ich eine Funktion aufrufe möchte ich schon wissen, ob daten geändert werden von dem was ich übergebe. das mache ich überall bei solchen funktionen und hat mir schon oft beim fehlerfinden geholfen.

Wie merkst du denn hier ob x oder y verändert wurde?

Mach doch dann

inline bool getTilePositionInSurface (wchar_t value, int& x, int& y)
{
    if (value == L'0') { x = 0; y = 0; return true; }
    if (value == L'1') { x = 1; y) = 0; return true; }
    if (value == L'2') { x = 2; y) = 0; return true; }
    if (value == L'3') { x = 3; y) = 0; return true; }
    if ....

    return false;
}

Jo mach switch-case. Mit wchar_t müsste das doch gehen.

int& ist in diesem Fall genauso wie int*.
Nur du brauchst in der Funktion nicht mehr (*x) = 0 zu schreiben sondern kannst direkt x = 0. Es gibt in diesem Fall keinen Unterschied.

hab ich jemals gesagt ob es da einen unterschied gibt? man nu stell dich doch mal nicht so dämlich an!

Es geht um den Aufruf!

Beispiel:

int x = 4, y = 5;

 getTilePositionInSurface (L'A', x, y);
 getTilePositionInSurface (L'A', &x, &y);

Beim 2. (meine variante) sehe ICH direkt ob x und y verändert werden, bei variante 1 sehe ich nicht ob sie nur benutzt wird oder ob sie auch verändert wird.

Boh! Auch noch rotz frech werden, wenn dir DEvent helfen will.

wenn er es seit sage und schreibe 3 posts nicht kapiert zeugt das nicht von seiner klugheit. frech war das nicht - nur ehrlich und direkt. dazu war nie die rede von einem rückgabewert, geschweige ob * und & das selbe machen. es ging nur um optimierung und um den aufruf, das man daraus sehen kann, das daten verändert werden. Bei seiner variante konnte man das nicht auf anhieb beim aufruf sehen.

inline void getTilePositionInSurface (wchar_t value, int* x, int* y) 
{ 
  if (!x || !y) return; 

  static int number[][2] = {{0,0}, {1,0}, ... , {1,2}};
  static int alpha [][2] = {{2,2}, {3,2}, ... , {3,3}};

  if (value >= L'0' and value <= L'9') {
    (*x) = number[value - L'0'][0];
    (*y) = number[value - L'0'][0];
  } else if (value >= L'A' and value <= L'F') {
    (*x) = alpha[value - L'A'][0];
    (*y) = alpha[value - L'A'][0];
  }
}

int wchar_to_int(wchart_t value) {
    if (value >= L'0' and value <= L'9') {
       return value - L'0';
    } else if (value >= L'A' and value <= L'F') {
       return value - L'A';
    }
    //throw exception
}

inline void getTilePositionInSurface (int value, int* x, int* y) 
{ 
  if (!x || !y) return; 

  (*x) = value % 4;
  (*y) = value / 4;
}

Die beiden Divisionen sollten sehr schnell gehen, da durch eine Zweierpotenz dividiert wird. Das macht der Kompiler schon ganz gut.

die division kann man doch mit einem bitshift beheben, oder?

Ja. Aber das ist hier nicht notwendig. Es macht den Code weniger wartbar, da es schlechter lesbar ist.

Der Kompiler macht schon daraus einen Bitshift, wenn es sich auf deiner Plattform lohnt. So was selbst zu machen bringt gar nichts.