Was meinst du mit halbe Zeile? Ist das so gemeint, dass die Zeilen aus zwei Teilen besteht, die durch ein Leerzeichen getrennt sind?

jede Zeile besteht aus 8 Zahlen, einem Leerzeichen und danach nochmal 4 Zahlen. "halbe Zeile" war wohl schlecht ausgedrückt; ich meinte allgemein einen Teil einer Zeile

jede Zeile besteht aus 8 Zahlen, einem Leerzeichen und danach nochmal 4 Zahlen. "halbe Zeile" war wohl schlecht ausgedrückt; ich meinte allgemein einen Teil einer Zeile

Ich glaube, du kennst den Unterschied zwischen Zahl und Ziffer nicht. Ich denke du meinst Ziffer und nicht Zahlen.

vector<pair<string,string>> daten;
ifstream file("test.txt")
for(string s1,s2; file>>s1>>s2; daten.push_back(make_pair(s1,s2)) );
// fertig

Du willst eine Zeile einlesen, das Leerzeichen entfernen und dann noch was an die Zeile anhängen. Verstehe ich das richtig?

Ja.
Wobei mir da grade einfällt, dass die Zahlen alle im Hexadezimalen system geschrieben sind, sodass ich da vielleicht auch irgendwas besonderes brauche, damit a,b,c,d,e und f nicht als ascii gespeichert werden, sondern als hexadezimal. (sofern das überhaupt geht)

out schrieb:

Ich habs so verstenden: Ziffernfolge Leerzeichen Ziffernfolge // So sieht jede Zeile aus?

Die Zeilen sehen z.b. so aus:
D033AFA1 0020
8133B1BC 4220
D033B1BD 0020
8133B17C 0300
D033B1BD 0020
8133B17E 0880

Ich habs so verstenden: Ziffernfolge Leerzeichen Ziffernfolge // So sieht jede Zeile aus?

Prinzipiell habe ich es auch so verstanden, aber er will das ja noch irgendwie wegschreiben. Den Teil verstehe ich noch nicht.

Die Zeilen sehen z.b. so aus:
D033AFA1 0020
8133B1BC 4220
D033B1BD 0020
8133B17C 0300
D033B1BD 0020
8133B17E 0880

OK, und was soll da nachher genau rauskommen, bzw was willst du damit genau machen?

Kazeshin schrieb:

Die Zeilen sehen z.b. so aus:
D033AFA1 0020
8133B1BC 4220
D033B1BD 0020
8133B17C 0300
D033B1BD 0020
8133B17E 0880

OK, und was soll da nachher genau rauskommen, bzw was willst du damit genau machen?

es soll in eine ROM an einer bestimmten stelle eingefügt werden. vorher sollte es zu
D033AFA10020008133B1BC422000D033B1BD0020008133B17C030000D033B1BD0020008133B17E088000
umgeschrieben werden.

Das hört sich so an, als solle das in ein Binärformat umgewandelt werden. Also z.B. die erste Zahl in ein tU32 und die zweite in ein tU16. Wie genau willst du das nachher in das ROM schreiben?

Wie sich mit Zahlen herumschlagen? Einfach 2 Strings nehmen und verknüpfen.

Wie sich mit Zahlen herumschlagen? Einfach 2 Strings nehmen und verknüpfen.

Ich fürchte er will nicht wirklich einen String schreiben sondern Bytes deren Werte durch Hexadezimalzahlen repräsentiert werden.

Das hört sich so an, als solle das in ein Binärformat umgewandelt werden. Also z.B. die erste Zahl in ein tU32 und die zweite in ein tU16. Wie genau willst du das nachher in das ROM schreiben?

Binär klingt richtig^^ nicht als ascii string, das wäre fatal^^

Btw: der code, den "out" geschrieben hat, hat zumindest schonmal die richtigen Ziffern ausgegeben.

Binär klingt richtig^^ nicht als ascii string, das wäre fatal^^

Wie genau schreibst du die Sachen denn ins ROM? Hast du dafür eine spezielle Funktion? Wenn ja, zeig mal die Signatur.

Kazeshin schrieb:

Binär klingt richtig^^ nicht als ascii string, das wäre fatal^^

Wie genau schreibst du die Sachen denn ins ROM? Hast du dafür eine spezielle Funktion? Wenn ja, zeig mal die Signatur.

Das ist mein Problem. Ich weiß nicht, wie das geht.

Das ist mein Problem. Ich weiß nicht, wie das geht.

Das solltest du irgendwie herausfinden. Hier kann leider niemand hellsehen und solange selbst du nicht weißt, was du genau machen möchtest, wird dir daher leider keiner helfen können.

Kazeshin schrieb:

Das ist mein Problem. Ich weiß nicht, wie das geht.

Das solltest du irgendwie herausfinden. Hier kann leider niemand hellsehen und solange selbst du nicht weißt, was du genau machen möchtest, wird dir daher leider keiner helfen können.

ich weiß, was ich damit tun will, das Problem ist nur, dass ich nicht weiß, wie ich diese Daten hereinbekomme. Sie sollen an eine bestimmte Stelle der Datei geschrieben werden. so wie ich es kenne, gibt es für jede 2. Hexadezimalstelle eine Addresse. Ich will die Zahlen an die Addresse BEA20 schreiben.

Nathan schrieb:

OK, mal ganz anders gefragt:
Was willst du mit diesen Zahlen im ROM erreichen?

Ich habe einen Assembler code für die N64 geschrieben, der die Zahlen ausliest. Dadurch erhält das Spiel ein "ingame gameshark device", das wie ein echte funktioniert. Das soll für Romhacks nützlich sein
Das Problem ist halt, dass es für den Nutzer verdammt nervig sein wird, 1000 (wirklich 1000 ._.) Ziffern einzutippen.

Willkommen im C++-Forum.

Erzähl mal ein wenig vom Hintergrund; dann können wir Dir auch besser helfen.
Wo kommen die Daten her (Quelle der Datei) und wo sollen die Daten hin und warum? und was sollen sie dort bewirken?

ROM steht für "Read Only Memory" - das ist Speicher, aus dem man nur Lesen, aber in dem man nicht schreiben kann. Vielleicht meinst Du RAM (random access memory).

Das was dort in der Datei steht, ist sogenannter HexCode. Es sollten also nur die Zeichen '0' bis '9' und 'A' bis 'F' dort vorkommen. Und zwar immer paarweise.
Wobei es überhaupt keine Rolle spielt, wenn zwischen den Paaren Leerzeichen auftauchen.
Jeweils zwei Zeichen bilden ein Byte und damit eine Zahl zwischen 0 und 255 (Hexadezimal 0x00 bis 0xFF). Mit C++ kannst Du Zahlen als Hexcode lesen. Auf Grund von einigen Gegebenheiten würde ich Dir hier aber empfehlen, Dir eine eigene kleine struct zu bauen, mit dem Du genau ein Byte einlesen kannst (also zwei Zeichen).

Hier mal ein Vorschlag - bitte frage nach - Du wirst einiges davon nicht verstehen.
Das Schreiben in 'ROM' habe ich geraten, da Du dazu noch nichts gesagt hast.

#include <iostream>
#include <iomanip> // setw
#include <fstream>
#include <cctype> // toupper

struct Byte
{
    char get() const { return value_; }
    friend std::istream& operator>>( std::istream& in, Byte& b );
private:
    char value_;
};
int calc_value_of_nibble( char nibble, bool& err ) // umwandel eines Zeichens '0'-'9' 'A'-'F' in dessen Wert 0-15
{
    const char hx[] = "0123456789ABCDEF";
    const char* p = std::char_traits< char >::find( hx, sizeof(hx)-1, char(std::toupper(nibble)) );
    if( p )
        return p - hx;
    err = true;
    return 0;
}
std::istream& operator>>( std::istream& in, Byte& b ) // Einlesen eines Bytes
{
    char high_nibble, low_nibble;
    if( in >> high_nibble && in.get( low_nibble ) )
    {
        bool err = false;
        b.value_ = calc_value_of_nibble( high_nibble, err )*16 + calc_value_of_nibble( low_nibble, err );
        if( err )
            in.setstate( std::ios_base::failbit );
    }
    return in;
}

// --   'ROM' nur für Demozwecke
class ROM
{
public:
    ROM()
    {
        std::clog.fill( '0' );
        std::clog << std::hex << std::uppercase;
    }
    void write( char byte )
    {
        std::clog << std::setw(2) << int(static_cast< unsigned char >( byte ));
    }
};

int main()
{
    using namespace std;
    ROM rom;
    for( ifstream in("input.txt"); (in >> ws).good(); )
    {
        int i=0;
        for( Byte b; i<6 && in >> b; ++i )
            rom.write( b.get() );
        rom.write( char(0) ); // nach 6 Byte eine 0 hinzufügen
    }
    cout << endl;
    return 0;
}

Gruß
Werner

Nathan schrieb:

OK, mal ganz anders gefragt:
Was willst du mit diesen Zahlen im ROM erreichen?

Ich habe einen Assembler code für die N64 geschrieben, der die Zahlen ausliest. Dadurch erhält das Spiel ein "ingame gameshark device", das wie ein echte funktioniert. Das soll für Romhacks nützlich sein
Das Problem ist halt, dass es für den Nutzer verdammt nervig sein wird, 1000 (wirklich 1000 ._.) Ziffern einzutippen.

Ah, Memory-Hack, hatte ich mir schon fast gedacht.
Für die Implementierung der write()-Funktion sollst du dir mal WriteProcessMemory() unter Windows anschauen

Hallo Kazeshin,

ROM steht für "Read Only Memory" - das ist Speicher, aus dem man nur Lesen, aber in dem man nicht schreiben kann. Vielleicht meinst Du RAM (random access memory).

Ne, der meint wahrscheinlich so was hier http://de.wikipedia.org/wiki/ROM_(Spielmodul). War auch die ganze Zeit auf dem falschen Dampfer aber langsam dämmert mir, was er vor hat.

Und vollkommen ungetestet, aber es könnte u.U. das machen was du willst (sofern es überhaupt compiliert). Und wenn nicht, sollte es dir ein paar Ideen geben.

#include <stdio.h>

int main()
{
    // files aufmachen
    FILE* patchFile = fopen("patch.txt", "r");
    // TODO: error handling
    FILE* romFile = fopen("rom.dat", "r+");
    // TODO: error handling

    // im ROM file dorthin seeken wo wir patchen wollen
    fseek(romFile, 0xBEA20, SEEK_SET);
    // TODO: error handling (ich lass das ab jetzt weg, ich hab hier gar kein error-handling, also fehlt es eh überall :D)

    // zeilenweise reinlesen
    char lineBuffer[100] = {};
    while (fgets(lineBuffer, sizeof(lineBuffer), patchFile))
    {
        unsigned long part1 = 0;
        unsigned long part2 = 0;
        // zwei hex zahlen aus der zeile lesen
        if (sscanf(lineBuffer, "%lx %lx", &part1, &part2) < 2)
            // TODO: message ausgeben -- dazu müssten wir aber erstmal auf ne leerzeile prüfen
            //       um unnötige warn-/fehlermeldungen zu vermeiden
            break;

        // in bytes zerlegen
        // hier reihenfolge ggf. umdrehen - je nachdem was für endian benötigt wird
        unsigned char patchBytes[4] = {
            ((part1 >> 24) & 0xFF),
            ((part1 >> 16) & 0xFF),
            ((part1 >> 8)  & 0xFF),
            ( part1        & 0xFF)
            };

        // ins ROM file schreiben
        fwrite(patchBytes, 1, 4, romFile);
    }

    // und files wieder zumachen
    fclose(patchFile);
    fclose(romFile);
}

Ich habe einen Assembler code für die N64 geschrieben, der die Zahlen ausliest. Dadurch erhält das Spiel ein "ingame gameshark device", das wie ein echte funktioniert.

Sorry, aber anhand deines Programmier-Kenntnisstandes ist wohl eher davon auszugehen dass du ihn dir ergoogelt hast. Ist aber andrerseits auch egal.

Und warum gehen eigentlich so viele davon aus, dass fgets & fseek und in anderen Threads alloc & free & strtok sofort von jedem DAP verstanden werden? .. wohingegen man für

char c;
    std::cin >> c;

ein Informatikstudium braucht.
Liegt vielleicht auch an C/C++-Kursen wie diesem hier (via Thread Schulaufgabe: Kleine Fehler.).

Gute Nacht