Écriture de plusieurs pointeurs de tableau dans un fichier avec ofstream?

Question

Je rencontre des problèmes très sérieux en écrivant plusieurs tableaux de données dans un fichier. Fondamentalement, je veux stocker toutes les tailles de tableau en haut du fichier, puis les données de tableau suivantes. De cette façon, je peux juste lire les tailles et utiliser cela pour construire des tableaux pour contenir les données à l'importation, et je saurai exactement où chaque tableau commence et se termine.

Voici le problème: j'écris les données, mais c'est différent à l'importation. S'il vous plaît jeter un oeil à mon petit code de test. En bas, il y a des commentaires sur les valeurs.

Merci beaucoup, collègues programmeurs! :)

#include <iostream> 
#include <fstream> 

int main() 
{ 
    int  jcount = 100, // First item in file 
      kcount = 200, 
      in_jcount, // Third item in file. jcount is used to find where this ends. 
      in_kcount; 

    float *j = new float[jcount], 
      *k = new float[kcount], 
      *in_j, 
      *in_k; 

    for(int i = 0; i < jcount; ++i) // Write bologna data... 
     j[i] = (float)i; 
    for(int i = 0; i < kcount; ++i) 
     k[i] = (float)i; 

    std::ofstream outfile("test.dat"); 

    outfile.write((char*)&jcount, sizeof(int)); // Good 
    outfile.tellp(); 

    outfile.write((char*)&kcount, sizeof(int)); // Good 
    outfile.tellp(); 

    outfile.write((char*)j, sizeof(float) * jcount); // I don't know if this works! 
    outfile.tellp(); 

    outfile.write((char*)k, sizeof(float) * kcount); // I don't know if this works! 
    outfile.tellp(); 

    outfile.close(); 


    std::ifstream in("test.dat"); 

    in.read((char*)&in_jcount, sizeof(int)); // == jcount == 100, good. 
    in.read((char*)&in_kcount, sizeof(int)); // == kcount == 200, good. 

    in_j = new float[in_jcount], 
    in_k = new float[in_kcount]; // Allocate arrays the exact size of what it should be 

    in.read((char*)in_j, sizeof(float) * in_jcount); // This is where it goes bad! 
    in.read((char*)in_k, sizeof(float) * in_kcount); 

    float jtest_min = j[0], // 0.0 
      jtest_max = j[jcount - 1], // this is 99. 

      ktest_min = k[0], // 0.0 
      ktest_max = k[kcount - 1], // this is 200. Why? It should be 199! 

      in_jtest_min = in_j[0], // 0.0 
      in_jtest_max = in_j[in_jcount - 1], // 99 

      in_ktest_min = in_k[0], // 0.0 
      in_ktest_max = in_k[in_kcount - 1]; // MIN_FLOAT, should be 199. What is going on here? 

    in.close(); 

    delete k; 
    delete j; 
    delete in_j; 
    delete in_k; 
} 

Answer 1

Il n'y a rien de mal à ce évidemment le code (en effet, je ne vois pas les erreurs que vous rencontrez lorsque je tente de l'exécuter), à l'exception du fait que vous n'êtes pas la vérification des erreurs d'ouverture de la fichiers d'entrée/sortie. Par exemple, si vous n'avez pas l'autorisation d'écrire dans «test.dat», l'ouverture échouera silencieusement et vous relirez tout ce qui se trouvait dans le fichier avant.

Answer 2

J'ai le même bug, je le fixer à l'aide d'un fichier binaire:

ofstream outfile; 
outfile.open ("test.dat", ios::out | ios::binary); 

et

ifstream in; 
in.open ("test.dat", ios::in | ios::binary);