Lesen von Binär-Dateien in ein array von ints in c++

Habe ich eine Methode, die schreibt eine binäre Datei von einer int array. (es könnte falsch sein)

void bcdEncoder::writeBinaryFile(unsigned int packedBcdArray[], int size)
{
    fstream binaryIo;
    binaryIo.open("PridePrejudice.bin", ios::out| ios::binary | ios::trunc);
    binaryIo.seekp(0);
    binaryIo.write((char*)packedBcdArray, size * sizeof(packedBcdArray[0]));
    binaryIo.seekp(0);

    binaryIo.close();
}

Muss ich jetzt gelesen, dass die Binär-Datei zurück. Vorzugsweise haben Sie es, Lesen Sie es wieder in ein anderes array von unsigned ints ohne Verlust der Informationen.

Ich habe so etwas wie den folgenden code, aber ich habe keine Ahnung, wie das Lesen binäre Dateien, die wirklich funktioniert, und keine Ahnung, wie es zu Lesen in ein array von ints.

void bcdEncoder::readBinaryFile(string fileName)
{
    //myArray = my dnynamic int array

    fstream binaryIo;
    binaryIo.open(fileName, ios::in | ios::binary | ios::trunc);

    binaryIo.seekp(0);

    binaryIo.seekg(0);
    binaryIo.read((int*)myArray, size * sizeof(myFile));

    binaryIo.close();
}

Frage:

Wie Sie an die Implementierung der Funktion, der liest binäre Dateien?

schreiben Sie eventuell die Größe des Arrays zuerst. Würde es erheblich vereinfachen das Lesen von code.
Um eine Notiz hinzuzufügen, hier kann ich nicht verwenden Vektor. Ich habe eine eigene Klasse erstellt dynamische arrays für mich mit einer bestimmten Größe übergeben, und die Klasse richtig funktioniert. Ich kann auch die Größe zu bestimmen auf der Grundlage der Informationen, die ich senden, um diese arrays.

InformationsquelleAutor Justin Tennant | 2015-09-23

binaryfiles c++dynamic-arrays

Zur Vereinfachung der read-operation betrachten, speichern size (ich.e die Anzahl der Elemente im array), bevor die Daten:

void bcdEncoder::writeBinaryFile(unsigned int packedBcdArray[], int size)
{
   fstream binaryIo;
   binaryIo.open("PridePrejudice.bin", ios::out| ios::binary | ios::trunc);
   binaryIo.seekp(0);
   binaryIo.write(&size, sizeof(size));
   binaryIo.write((char*)packedBcdArray, size * sizeof(packedBcdArray[0]));
   binaryIo.close();
}

Lesen würde folgendermaßen Aussehen:

void bcdEncoder::readBinaryFile(string fileName)
{
    std::vector<unsigned int> myData;
    int size;

    fstream binaryIo;
    binaryIo.open(fileName, ios::in | ios::binary | ios::trunc);

    binaryIo.read(&size, sizeof(size)); //read the number of elements 

    myData.resize(size); //allocate memory for an array 
    binaryIo.read(myData.data(), size * sizeof(myData.value_type));
    binaryIo.close();

   //todo: do something with myData
}

Ich vermute nun, dass mein schreiben ist einfach nur komplett falsch. First off, das &Größe in dem schreiben schlägt fehl, weil es sagt, dass seine erwartet einen char, aber insgesamt, wenn ich in meinem packedBcd Array (die ich kenne, hat die richtige Werte) die Werte sind nicht geschrieben in der .bin-Datei in einer Weise, die ich verstehen, wenn überhaupt.
binaryIo.Lesen(&size, sizeof(size)); wie funktioniert das kompilieren?

InformationsquelleAutor alexm

Wenn Sie mit C++, das schöne std Bibliothek.

vector<unsigned int> bcdEncoder::readBinaryFile(string fileName)
{
    vector<unsigned int> ret; //std::list may be preferable for large files
    ifstream in{ fileName };
    unsigned int current;
    while (in.good()) {
        in >> current;
        ret.emplace_back(current);
    }
    return ret;
 }

Schreiben ist genau so einfach wie (für diesen werden wir annehmen int[] aber ein std-Bibliothek vorzuziehen wäre):

void bcdEncoder::writeBinaryFile(string fileName, unsigned int arr[], size_t len)
{
    ofstream f { fileName };
    for (size_t i = 0; i < len; i++)
        f << arr[i];
}

Hier ist die gleiche Sache, aber mit einem std::vector

void bcdEncoder::writeBinaryFile(string fileName, vector<unsigned int> arr)
{
    ofstream f { fileName };
    for (auto&& i : arr)
        f << i;
}

Ich kann nicht herausfinden, einen Weg zu implementieren, der eine ähnliche Methode Lesen, ohne Vektoren, die ich bin nicht in der Lage, den Einsatz in diesem Projekt.
Sie sind ganz und gar verboten, mit einem vector oder Sie sind einfach erforderlich, um eine int[]?
Teil des Projekts Ziel war es, gelten die zuvor benutzerdefinierte dynamische array-Klasse-Datei in ein neues Projekt.

InformationsquelleAutor Olipro

Danke für die Tipps Jungs, sieht aus wie ich arbeitete es aus!! Ein großer Teil meines Problems war, dass die Hälfte der Argumente und die syntax, die ich Hinzugefügt, um die Methoden waren nicht erforderlich, und tatsächlich vertan. Hier sind meine Arbeitsmethoden.

void bcdEncoder::writeBinaryFile(unsigned int packedBcdArray[], int size, string fileName)
{
    ofstream binaryIo;
    binaryIo.open(fileName.substr(0, fileName.length() - 4) + ".bin", ios::binary);
    if (binaryIo.is_open()) {
        binaryIo.write((char*)packedBcdArray, size * sizeof(packedBcdArray[0]));
        binaryIo.close();

        //Send binary file to reader
        readBinaryFile(fileName.substr(0, fileName.length() - 4) + ".bin", size);
    }
    else
        cout << "Error writing bin file..." << endl;
}

Und das Lesen:

void bcdEncoder::readBinaryFile(string fileName, int size)
{
    AllocateArray packedData(size);
    unsigned int *packedArray = packedData.createIntArray();

    ifstream binaryIo;
    binaryIo.open(fileName, ios::binary);
    if (binaryIo.is_open()) {
        binaryIo.read((char*)packedArray, size * sizeof(packedArray[0]));
        binaryIo.close();

        decodeBCD(packedArray, size * 5, fileName);
    }
    else
        cout << "Error reading bin file..." << endl;
}

Mit der AllocateArray meine Klasse, die erstellt dynamische arrays ohne Vektoren halbwegs sicher mit Destruktoren enthalten.

InformationsquelleAutor Justin Tennant

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.