Table-Funktion

Hi

eine einfache Lookup-Tabelle in Form eines Arrays?

const char lookup[] = {0xA1, 0x33, 0x22, ...};

Matthias

Hi

1.
Die Adresse eines bestimmten Eintrags findest du mit dem
Adressoperator:

char * p = &lookup[3];

2.
char c = lookup[3]; liefert den 4. Eintrag in der Tabelle.

Matthias

Warnung: ungetesteter Code

struct Entry
{
  unsigned char Original;
  unsigned char Replacement;
};

struct Entry Table[] =
 {
   { 0x31, 0xA1 },
   { 0x32, 0x33 },
   { 0x33, 0x21 },
   { 0x44, 0x03 }
 };

unsigned char Replace( unsigned char Orig )
{
  int i;
  for( i = 0; i < sizeof( Table ) / sizeof( Table[0] ); ++i ) {
    if( Table[i].Original == Orig )
      return Table[i].Replacement;
  }

  return 0x00;    /* Im Fehlerfall */
}

> naja würde dann eher ein Hashtable vorziehen

Kommt drauf an ueber wieviele Werte wir hier reden
und welche Laufzeiten eingehalten werden muessen.

Hash-Table:
Im Prinzip ist das ganz einfach: Wenn es moeglich ist
aus dem Suchwert die Adresse des gesuchten Elements direkt
zu errechnen, dann kann man sich die Schleife sparen, die
sequentiall nach dem Original Wert sucht.

In Deinem Fall ist das ganz einfach: Dein Suchwert ist ein
unsigned char, d.h. es gibt nur 256 moegliche Werte. Man
baut daher ein Array mit 256 Eintraegen auf. Lautet eine
Ersetzung zb. dass der Wert 0x31 mit 0xA1 ersetzt werden muss,
dann wird das Array an der Stelle 0x31 mit 0xA1 besetzt usw. usw.

Die Uebersetzung selbst geschieht dann einfach so:

unsigned char Table[] =
{ 0x00, 0x00, 0x00, 0x00, ... /* insgesamt 0x30 Eintraege */
  0xA1,
  0x00, 0x00, ...             /* bis 256 Eintraege beisammen sind */
};

unsigned char Replace( unsigned char Orig )
{
  return Table[ Orig ];
}

Natuerlich muessen das nicht unbedingt 256 Eintraege sein. Wenn
Du zb. weist, dass niemals Orig Werte groesser 128 vorkommen werden,
dann kann das Array auch kleiner sein. Wenn Du weist, dass niemals
Werte kleiner als 64 vorkommen, dann laesst man die ersten 64 Werte
weg und subtrahiert vor dem Arrayzugriff die 64. Etc.
Aber das Prinzip ist immer das gleiche: Der zu uebersetzende Wert
wird irgendwie in einen Index auf das Sucharray umgerechnet und
damit dann direkt zugegriffen. Auch wenn das bedeutet, dass einige
Werte im Sucharray niemals angesprochen werden, also Luecken drinn
sind.