Typumwandlung [string->DWORD]



  • Guten Tag,

    ich habe ein kleines Problem mit einem Projekt an dem ich gerade arbeite.
    Und zwar möchte ich aus einer Textdatei Zeilenweise etwas auslesen (Das klappt soweit auch).
    Jedoch kann ich das Ausgelesene nur in einer String Variablen abspeichern.
    Um mit den eingelesenen Daten weiter arbeiten zu können, brauche ich diese jedoch in DWORD.

    #include <fstream>
    #include <iostream>
    #include <windows.h>
    using namespace std;
    
    int main()
    {
      ifstream infile("config.txt");
      string line;
      getline(infile, line);
    
      std::cout << line << std::endl;
      // Nun soll "string line" umgewandelt werden...
    
      /* REST DES PROGRAMM-CODES ENTFERNT (NICHT RELEVANT)*/
    
      cin.get();
    }
    

    Kann ich die Zeilen direkt in DWORD einlesen?
    Oder besteht die Möglichkeit eine String Variable in DWORD zu casten?

    Wäre euch wirklich dankbar, falls ihr mir helfen könntet.

    Liebe Grüße, FaNTaCoLa



  • Erzähl mal wie es weitergeht.

    typedef unsigned long       DWORD;
    

    Das macht nicht viel Sinn.



  • Da DWORD nur ein typedef für uint oder ulong ist, gehz das genauso wie mit diesen Typen auch.
    Also entweder direkt

    infile >> dein_dword
    

    oder mit stringstreams.



  • DWORD value = atoi(line.c_str());
    

    Damit kann ich als String ausgelesene Zahlen in DWORD umwandeln.

    @brotbernd
    Ich versuche momentan Offsets aus dem Programmcode auszulagern.
    Diese möchte ich aus einer Textdatei auslesen. (So kann ich die Offsets jeder Zeit ändern)

    Im Programmcode speichere ich die Offsetadressen normalerweise aus dieser Art:

    DWORD adresse_eins = 0xCC19918;
    

    Jedoch bekomme ich hierbei Probleme beim Auslesen einer Textdatei wegen dem "x" und den Buchstaben.

    Vielen Dank schonmal an euch beide.
    Ich hoffe, dass jemand von euch einen weiteren Ansatz für mein neues Problem hat.

    Liebe Grüße, FaNTaCoLa


  • Mod

    Wenn atoi die Schreibweise mit dem 0x nicht kennt (wundert mich jetzt ehrlich gesagt), dann nimm Stringstreams zur Umwandlung (Siehe FAQ), die können das auf jeden Fall.



  • Ich hab mich ein wenig über "Stringstreams" erkundig und bin nun zu Folgendem gekommen:

    #include <sstream>
    #include <string>
    #include <iostream>
    #include <strstream> 
    using namespace std;
    
    int main()
    {
    ifstream infile("config.txt");
    string line;
    getline(infile, line);
    
        stringstream Str;
        Str << line;
        DWORD d;
        Str >> d;
        cout << d << endl; 
    
    /* REST DES PROGRAMM-CODES ENTFERNT (NICHT RELEVANT)*/
    
    cin.get();
    }
    

    Wenn die Textdatei z.B. so aussieht, dann ist alles ok:

    123
    234
    etc PP
    

    -> 123 wird ausgegeben

    Falls ich aber ein Offset einlesen will (z.B. so):

    0x244C5
    0x24455
    

    -> Eine 0 bei der Ausgabe der umgewandelten DWORD Variable ausgegeben.
    Wisst ihr was ich falsch mache?

    Liebe Grüße, FaNTaCoLa





  • #include <fstream>
    #include <sstream>
    #include <string>
    #include <iostream>
    #include <strstream>
    #include <windows.h>
    using namespace std;

    int main()
    {
    ifstream infile("config.txt");
    string line;
    getline(infile, line);

    stringstream Str;
    Str << hex << line;
    DWORD d;
    Str >> d;

    cout << hex << d << endl;

    /* REST DES PROGRAMM-CODES ENTFERNT (NICHT RELEVANT)*/

    cin.get();
    }

    Danke, brotbernd 🙂
    Jetzt werden die regulären Zahlen endlich richtig dargestellt (Mit den Buchstaben des Hexadezimalsystems).
    Ein kleines Problem habe ich jedoch noch immer.
    Die "0x" des Offsets werden nicht angezeigt.

    Weiß jemand wie ich dieses(letzte) Problem noch lösen könnte?

    Liebe Grüße, FaNTaCoLa


  • Mod

    Mit showbase.

    Oder man kann natürlich auch einfach manuell "0x" davorschreiben 😉 .



  • Das mit dem manuellen Davorschreiben war mir auch bekannt 🙂
    Jedoch habe ich die ganzen Ausgaben nur dazu benutzt, um die bisherigen Ergebnisse zu überprüfen.

    Am Ende soll die ausgelesene Zeile in einer DWORD Variable gespeichert sein (mit "0x").
    Die Ausgabe (als Prüfverfahren) werde ich natürlich entfernen.

    Wie kann ich der DWORD Variablen erteilen, dass es bei dessen Abruf nur die Hexadezimalzahl mit "0x" ausgibt?
    Bisher wurde ja nur bei der Ausgabe das Zahlensystem gewechselt und "0x" einfach davor geschrieben.
    ( Die DWORD Variable an sich hat das "0x" jedoch nicht gespeichert)

    Sinngemäß soll der DWORD Variablen durch das Auslesen Folgendes zugewiesen werden:

    DWORD line = 0xCC19918;
    

    Liebe Grüße, FaNTaCoLa


  • Mod

    Die Variable speichert einen Wert, keine Darstellung in einem Zahlensystem. Das ist ein ganz wichtiger Unterschied, den du dir klarmachen musst.

    Falls du bestimmte Darstellungen von Werten speichern willst (ohne diese einfach aus dem Wert zu berechnen), musst du so etwas wie ein char-Array oder einen String benutzen.



  • Ok, danke dir.

    Kann ich die, in der DWORD Variable gespeicherte Zahl, auch mit irgendeiner Funktion in eine Hexadezimalzahl umwandeln und dann in eine weitere DWORD Variable speichern?

    Ich habe bisher leider nur etwas komplizierte Ansätze dazu gefunden.
    Gibt es eine Funktion, der man die "alte" Variable übergibt und die Hexadezimalzahl ausgibt?

    Liebe Grüße, FaNTaCoLa


  • Mod

    Nochmal: Die Variable speichert den Wert einer Zahl, nicht die Darstellung einer Zahl in einem Zahlensystem. Ist dir der Unterschied nicht klar?



  • Nach deiner Antwort beführchte ich, dass ich etwas falsch verstanden habe bzw nicht verstehe.

    Wenn ich zum Beispiel eine Variable habe:

    int a = 51;
    

    Dann kann ich diese ja mit Hilfe dieser Manipulatoren z.B. in Hexadezimal ausgeben.

    Wenn ich aber genau diese Hexadezimalausgabe in einer anderen Variablen gespeichert haben möchte, was kann ich dann machen?

    Falls ich von grundlegend falschen Annahmen ausgehe, würde es mich freuen, wenn mich jemand diesbezüglich aufklären würde 🙂

    Liebe Grüße, FaNTaCoLa


  • Mod

    Darstellungen einer Zahl sind im Prinzip Zeichenfolgen und müssen auch als solche behandelt werden, wenn du sie speichern willst.

    Wenn du int a = 51; machst, dann speichert a das abstrakte Konzept der Zahl Einundfünfzig, nicht die Zeichen '5' und '1'. Es ist vollkommen egal, ob du darüber als Einundfünzig, Fifty-one, cinquante-et-un, LI (römisch), 5110, 1100112, 638, 4312, 3316 oder IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII denkst. Der Wert der Zahl ist immer der gleiche.



  • Ich glaube, dass ich heute Abend ein wenig auf dem Schlauch stehe.

    Angenommen ich habe:

    int a = 51;
    

    Dann wird das im Hintergrund gespeichert.
    Dass die erwähnten Zahlen in den unterschiedlichen Zahlensystemen den selben Wert haben, ist soweit klar.

    ABER wenn ich nun ein Offset speichern möchte...
    Ich habe bisher immer gedacht, dass dieser mit "0x"+Hexadezimalzahl angegeben werden muss.

    Wenn ich deinen letzten Post richtig verstehe, ist es dann auch möglich den Offset so darzustellen: "0x"+Dezimalzahl (selber Wert wie die zuvorgenannte Hexadezimalzahl)

    Habe ich das nun richtig verstanden?

    Liebe Grüße, FaNTaCoLa


  • Mod

    Ahh, ich glaube ich weiß wo es bei dir hakt: "0x" bedeutet einfach nur "die folgende Zahl ist in Hexadezimaldarstellung angegeben" (alos 0x10 ist 16 in Dezimalsystem). Ebenso gibt es die Schreibweise "0" die besagt "die folgende Zahl ist in Oktaldarstellung angegeben" (also 010 ist 8 im Dezimalsystem). Das ist einfach nur eine Konvention um beim Programmieren auf einfache Weise Zahlen in den gängigen Basen angeben zu können.



  • strtoul mit Radix 16 .

    Gruß


Log in to reply