fichier binaire

Question

sais que cela peut être assez basique, mais je tente de comprendre comment un après créer un tableau dynamique tel que

double* data = new double[size]; 

être utilisé comme source de données à conserver dans un fichier binaire tel que

ofstream fs("data.bin",ios:binary"); 
fs.write(reinterpret_cast<const char *> (data),size*sizeof(double)); 

Quand je fini d'écrire, je tente de lire le fichier par

double* data = new double[size]; 
ifstream fs("data.bin",ios:binary"); 
fs.read(reinterpret_cast<char*> (data),size*sizeof(double)); 

Cependant, il semble que je rencontre une erreur d'exécution lors de la lecture des données. Avez-vous des conseils sur la façon dont je devrais essayer d'écrire un tableau dynamique en utilisant des pointeurs transmis par d'autres méthodes pour être stockés dans des fichiers binaires?

Answer 1

1. Hy :)

If you use Unix you have some functions: int read(int fd, void 

* buf, int count) ;. int écrire (int fd, void * buf, int nbytes) ;.

The functions are verry fast because 
are kernel-functions. 

i run your code and everything was 
ok : 

     1 #include <iostream> 
     2 #include <fstream> 
     3 #include <cstring> 
     4 using namespace std; 
     5 
     6 int main() 
     7 { 
     8  double * s; 
     9  int ns = 10;     //information 
    10  s = new double[ns]; 
    11 
    12  for (int i = 0 ; i < ns ; ++i) 
    13   s[i] = 17*i + 23;   // i put my information here 
    14 
    15  ofstream os("data.txt", ios::binary); 
    16  os.write(reinterpret_cast<const char*> (s), sizeof(double) * ns); 
    17  os.close(); 
    18 
    19  double * final; 
    20  final = new double[ns]; 
    21 
    22  ifstream is("data.txt", ios::binary); 
    23  is.read(reinterpret_cast<char *>(final), sizeof(double) * ns); 
    24  is.close(); 
    25 
    26  for (int i=0; i < ns; ++i) 
    27   cout<<s[i]<<" "<<final[i]<<"\n"; 
    28 
    29  return 0; 
    30 } 

~    

none@Brusture:~/Desktop$ g++ -o test 
test.cpp none@Brusture:~/Desktop$ 
./test 23 23 40 40 57 57 74 74 91 
91 108 108 125 125 142 142 159 159 
176 176 

Answer 2

cours d'eau ne sont pas le seul ni toujours la meilleure façon d'accéder à des fichiers binaires. Ceci est une autre façon qui utilise les mécanismes de la mémoire virtuelle du système d'exploitation (la même chose que faire de votre échange de mémoire sur le disque):

template<class T> 
    struct BinaryData{ 
    BinaryData(std::string const& fname,unsigned size):_size(size) { 
     int fd=open(fname.c_str(),O_RDWR,O_CREAT); 
     //if modifying to different size or creating 
     ftruncate(fd,size*sizeof(T)); 
     //get the memory 
     _data=reinterpret_cast<T*>(mmap(0,size*sizeof(T),PROT_WRITE|PROT_READ,MAP_SHARED,fd,0)); 
     fclose(fd); 
    } 

    ~BinaryData(){ 
     munmap(_data); 
    } 
    T* begin(){return _data; } 
    T* end(){return _data+_size; } 
    private: 
    T* _data; 
    unsigned _size; 
    }; 

Cela rend simplement l'échange de mémoire dans un fichier d'échange differnt, à savoir celui vous spécifiez Les drapeaux choisis le forceront toujours à écrire le contenu sur le disque, soit à la sortie du programme, soit à l'invocation de munmap. Cet exemple n'a bien sûr rien à voir avec la vérification des erreurs et la syntaxe ne fonctionne que sur les systèmes POSIX. Cependant Windows a une sémantique identique dans sa fonction CreateFileMapping.