Newsgroup: it.comp.lang.c++
Titolo: problemi con vector

Ciao ragazzi, vorrei sapere se č possibile scrivere/leggere su file un
vettore dinamico (creato con l'istruzione vector della libreria
vector.h) tramite le funzioni fwrite e fread.
Piů precisamente :
struct A{
    int b;
    int c;
};
vector<A> a;
E' possibile scrivere/leggere "a" con fwrite/fread. Cosa devo passare
come parametro a sizeof()?
Grazie.
M.


Perchč non provi a fare I/O nel metodo che dici tu??
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Perchč non provi a fare I/O nel metodo che dici tu??
Cioč? Non capisco.
Il Fatto č che una volta scritto su file il vettore "a", poi quando vado
a leggerlo, mi spara numeri a caso.
Quello che faccio č:
...
fwrite(&a,sizeof(A),1,fp); // fp č il puntatore al file
...
fread(&a1,sizeof(A),1,fp); //a1 č dello stesso tipo di a ovviamente
...
Quando perň stampo a video a1, non c'č quello che ho scritto.

 
Non va bene. Il fatto che tu abbia anche solo pensato di poter copiare il 
vector in questo modo, mostra che hai una comprensione un po' 
approssimativa di cosa sia un oggetto in C++.
Ora, quando si tratta di salvare, trasmettere, copiare una struttura dati 
verso l'esterno o ripristinarla dall'esterno, la prima distinzione che 
occorre fare è quella tra strutture POD e strutture non POD. E' una 
distinzione cruciale, se si vogliono evitare disastri.
POD (Plain Old Data) sono, in buona sostanza, tutte quelle strutture che 
sono implementate con costrutti tipici del C (non C++) usando 
esclusivamente tipi built-in, struct o array. Ora, prendiamo un 
sottoinsieme di questo tipo di strutture: quelle prive di puntatori. Ecco, 
di questo tipo di dati è possibile (ma non è affatto detto che sia sempre
ragionevole) salvarne o ripristinarne il valore leggendo o riscrivendo la 
regione di memoria che essi occupano. Per qualsiasi altro tipo di dati, 
un'operazione del genere è assolutamente priva di senso e se eseguita 
produce disastri. 
Fatta questa premessa, veniamo al tuo problema. Se quello che ti interessa 
è soltanto salvare e ripristinare (senza varcare i confini della tua 
piattaforma) un vector di interi usando 'fwrite' e 'fread' puoi procedere 
in questo modo:
  std::vector<int> vect;
  // *salvare*
  if( vect.size() )
  {  
      // ricavo l'indirizzo del primo elemento
      const int* first_rdptr = &vect[0]; 
      // scrivo l'array di int
      fwrite( first_rdptr, sizeof(int), vect.size(), fp  ); 
  }
  // *ripristinare*
  // (assumendo che tu sappia quanti elmenti devi leggere
  // e che questo valore sia 'count')
  vect.resize(count);
  int* first_wrptr = &vect[0];
  fread( first_rdptr, sizeof(int), vect.size(), fp  ); 
 
Questo procedimento funziona soltanto se 
  - il vector contiene interi (come nel nostro caso), oppure,
     in generale, tipi POD privi di puntatori
  e
  - i dati non devono essere scambiati tra piattaforme diverse
    (endianness)
Se la tua esigenza non è limitata a questa casistica, la questione diventa 
più complessa e non può essere affrontata con questo approccio. Nel caso 
generale di oggetti o strutture dati arbitrarie, si parlerà di 
"serializzazione"/"serialization". (Puoi usare quei due termini per cercare 
su Google e approfondire la questione.)
Max

Max M. ha scritto:
[CUT]
Grazie 1000.
M.