4-Byte-Zahl als 4-Textzeichen darstellen und umgekehrt

Leo Freitag

Hallo,

zum Schreiben und Lesen von Daten auf einen (speziellen) USB-Stick, der nur Zahlenwerte (4-Byte) zulässt, benötige ich eine entsprechende Routine.

Ich vermute irgendeine Art von cast könnte das bewerkstelligen, hat jemand eine Idee?

Gruß
Leo

virtuell Realisticer

Hallo,

wenn ich das richtig verstehe, dann willst du eine Zahl, welche 4-Byte Speicher
belegt, als C-Zeichenkette interpretieren. Sprich als 4 Zeichen, da ein Zeichen
ein Byte gross ist. Das sollte ohne Probleme funktionieren, wenn du die Zahl
nach char* castest.

mfg
v R

Leo Freitag

virtuell Realisticer schrieb:

Hallo,

wenn ich das richtig verstehe, dann willst du eine Zahl, welche 4-Byte Speicher
belegt, als C-Zeichenkette interpretieren. Sprich als 4 Zeichen, da ein Zeichen
ein Byte gross ist. Das sollte ohne Probleme funktionieren, wenn du die Zahl
nach char* castest.

mfg
v R

Hallo,
danke für Deinen Tipp, aber irgendetwas mache ich noch falsch, denn ich bekomme eine Laufzeitfehler beim Versuch, das char-Array mit 0 zu terminieren.

int iZahl = 4294967290;
char* cFld = new char[5];
cFld = (char*) iZahl;
cFld[4] = '\0'; // Feld mit 0 terminieren

Gruß
Leo

virtuell Realisticer

Das ist auch nicht moeglich. Deine Zahl (int) belegt 4-Byte Speicher. Castest du
jetzt nach char*, dann stehen dir weiterhin nur diese 4-Byte Speicher zur
Verfuegung. Alles was danach kommt gehoert dir wahrscheinlich nicht.

int zahl = 12345;
char* p = reinterpret_cast<char*>(&zahl);
//p[0] == erstes zeichen
//p[1] == zweites zeichen
//p[2] == drittes zeichen
//p[3] == viertes zeichen
//p[4] == ups...gehoert uns nicht mehr. das waere das 5. Byte

mfg
v R

Leo Freitag

virtuell Realisticer schrieb:

Das ist auch nicht moeglich. Deine Zahl (int) belegt 4-Byte Speicher. Castest du
jetzt nach char*, dann stehen dir weiterhin nur diese 4-Byte Speicher zur
Verfuegung. Alles was danach kommt gehoert dir wahrscheinlich nicht.
int zahl = 12345;
char* p = reinterpret_cast<char*>(&zahl);
//p[0] == erstes zeichen
//p[1] == zweites zeichen
//p[2] == drittes zeichen
//p[3] == viertes zeichen
//p[4] == ups...gehoert uns nicht mehr. das waere das 5. Byte
mfg
v R

Danke, das habe ich gesucht!

Verstehe ich richtig, dass hier nicht der Speicherinhalt verschoben wird (da ja zuvor kein Speicher reserviert wurde), sondern lediglich der Typ des Zeigers geändert wird!? Und wenn ja, dann wage ich mir ja gar nicht vorzustellen, was passiert, wenn ich anschließend erneut auf zahl (vom Typ int) zugreifen will.
Oder ist es vielleicht noch mysteriöser, dass mit 'p' einfach ein weiterer Pointer auf einen bereits adressierten Speicherbereich gesetzt wird?

Gruß
Leo

virtuell Realisticer

Mit einem Cast aenderst du die Art und Weise, wie eine Variable interpretiert
wird. Ein Integer wird als eine 4-Byte Variable interpretiert. Ein char als eine
1-Byte Variable.

Da ein Integer 4-Byte belegt und du diesen zu einem char* castest, aenderst du
die Interpretation des Speicherbereichs. Dadurch kannst du nun auf alle 4-Byte
einzeln zugreifen. Aenderst du ein Byte, aendert sich logischer Weise auch die
Zahl. Du kannst das ja mal ausprobieren:

int zahl = 12345;
char* p = reinterpret_cast<char*>(&zahl);
//nur das verbiegen eines zeiger ist keine gefahr. aber wenn schreibend auf die
//variable zugegriffen wird, dann aendert sich auch 'zahl'
cout<<p[0]<<" "<<p[1]<<" "<<p[2]<<" "<<p[3]<<endl;
p[1] = 8;
cou<<zahl<<endl;

mfg
v R

Leo Freitag

virtuell Realisticer schrieb:

Mit einem Cast aenderst du die Art und Weise, wie eine Variable interpretiert
wird. Ein Integer wird als eine 4-Byte Variable interpretiert. Ein char als eine
1-Byte Variable.

Da ein Integer 4-Byte belegt und du diesen zu einem char* castest, aenderst du
die Interpretation des Speicherbereichs. Dadurch kannst du nun auf alle 4-Byte
einzeln zugreifen. Aenderst du ein Byte, aendert sich logischer Weise auch die
Zahl. Du kannst das ja mal ausprobieren:
int zahl = 12345;
char* p = reinterpret_cast<char*>(&zahl);
//nur das verbiegen eines zeiger ist keine gefahr. aber wenn schreibend auf die
//variable zugegriffen wird, dann aendert sich auch 'zahl'
cout<<p[0]<<" "<<p[1]<<" "<<p[2]<<" "<<p[3]<<endl;
p[1] = 8;
cou<<zahl<<endl;
mfg
v R

Hallo,

sehr interessante Geschichte!

Habe mich mittlerweile auch mit dem umgekehrten Weg beschäftigt: 4-Zeichen-char nach int konvertieren. Anbei der (C++Builder)-Code: Struct und zwei Methoden.

struct TVierByteZeichen
{
    char cFld[4];
};

// ...

inline int fct_4ByteZeichen_nach_Zahl(AnsiString asZeichen)
{
    int iBack = -1;

    TVierByteZeichen vbz; // 4-Zeichen-Struct
    strcpy(vbz.cFld, asZeichen.c_str()); // AnsiString nach 4-Zeichen-Struct

    int* pi = reinterpret_cast<int*>(&vbz);
    iBack = *pi;
    return iBack;
}
//---------------------------------------------------------------------------

inline AnsiString fct_4ByteZahl_nach_Zeichen(int iZahl)
{
    AnsiString asBack = "";
    char* p = reinterpret_cast<char*>(&iZahl);
    asBack = AnsiString("") + p[0] + p[1] + p[2] + p[3];
    return asBack;
}

Bei ersten Versuchen scheint auch alles wie gewünscht zu funktionieren. Wenn ich jedoch kleinere Zahlenwerte wie z.B. 260 in Text konvertiere und anschließend wieder zurück, erhalte ich einen wesentlich höheren Wert. Woran kann das liegen?

Gruß
Leo

virtuell Realisticer

Nabend,

ich glaube du missverstehst etwas. Hier wird _nicht_ Text in Zahl bzw. Zahl in
Text konvertiert. Hier wird lediglich das Bitmuster anders interpretiert.

Bei char werden immer 8 Bit interpretiert, bei int immer 32 Bit.

Beispiel:

du hast die Zahl 2:

int zahl = 2;
char* p = reinterpret_cast<char*>(&zahl);
                                                    interpretiert als
Bitmuster                                      Zahl(integer)     Zeichen(char)
0000 0000 0000 0000 0000 0000 0000 0010             2          3. Steuerzeichen
   \/        \/        \/        \/
  p[3]      p[2]      p[1]      p[0]

Bei der Zahl werden alle 32 Bits interpretiert. Beim Zeichen immer nur 8 Bit.

Noch ein Beispiel:

int zahl = 65;
char* p = reinterpret_cast<char*>(&zahl);
                                                    interpretiert als
Bitmuster                                      Zahl(integer)     Zeichen(char)
0000 0000 0000 0000 0000 0000 0100 0001             65               A
   \/        \/        \/        \/
  p[3]      p[2]      p[1]      p[0]

mfg
v R