Table-Funktion

[Michael Kleinknecht (Gast)]

Hallo,

ich suche eine Funktion mit:

INPUT  : einzelner Char
OUTPUT : Input wird ein anderes Char als OUTPUT zugeordnet

dazu benötige ich eine Art Table:

INPUT --> OUTPUT
0x31  --> 0xA1
0x32  --> 0x33
0x33  --> 0x21
0x44  --> 0x03
...


gibt es eine andere Möglichkeit als die folgende switch Anweisung
anzuwenden? Es besteht kein mathematischer Zusammenhang.

switch INPUT
   case 0x00
     OUTPUT == 0x43
   case 0x01
     OUTPUT == 0x55
   ...

Über Ideen wie ich so etwas realisieren kann bin ich sehr dankbar.

[Μαtthias W. (matthias)]

Hi

eine einfache Lookup-Tabelle in Form eines Arrays?

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

Matthias

[Michael Kleinknecht (Gast)]

Vielen Dank für die schnelle Hilfe. Ja, so eine Table suche ich. Ich
kann leider nur Matlab-Programmieren, vielleicht kannst Du mir deshalb
noch eine kurze Info dazu geben:

1. Wie kann ich herausfinden welche Adresse der gewünschte Input im
Array besitzt?

z.B. 0x33

2. Wie kann ich einen bestimmten Wert diese Arrays auslesen?

x=lookup[3]; ?

[Μαtthias W. (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

[Karl H. (kbuchegg)]

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 */
}

[... (Gast)]

naja würde dann eher ein Hashtable vorziehen

INPUT --> REal-IDX-->OUTPUT
0x31-0x31 --> 0 --> 0xA1
0x32-0x31 --> 1  --> 0x33
0x33-0x31 --> 2  --> 0x21
usw....
0x44  --> 0x03

Speicher gegen Loops... tauschen ;-)

[Michael Kleinknecht (Gast)]

Ich habe jetzt die Lösung vom Karl implementiert und es funktioniert für
meine Zwecke perfekt. Danke.

Das mit der Hash-Table verstehe ich nicht ganz (Speicher vs. Loops)?

Danke für die vielen schnellen und hilfreichen Antworten. Falls einer
mal ein Problem in Matlab haben sollte, werde ich mich natürlich gerne
revanchieren -> E-Mail.

[... (Gast)]

Speicher ... gegen Loops

... im ersten Vorschlag kommt z.B. 5 x der 99te Wert im Array ...
macht also 5 x 100 Umläufe im Loop - kostet also immer viele Takte ....
ich muss aber nur die "realen" varianten ablegen

... zweiter Vorschlag ... Array kostet 99 Werte im Array, und ich füre
den Eingangswert Linear auf den Wert im Array zurück - ein Zugriff im
Array ....

[Karl H. (kbuchegg)]

> 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.