Newsgroup: it.comp.lang.c++
Titolo: Scrivere una stringa su un ofstream

Ho creato una piccola classe bitstring che tra i membri pubblici ha
una stringa, finito di scrivere sulla stringa vorrei copiarla su di
un file creato con la dicitura
ofstream out ("out.dat")
Ebbene ho fatto una prova con una stringa da 30 byte e scrivendo
out<<oggetto_bitstring.stringa;
tutto funziona correttamente, l'intera stringa e' copiata sul file,
allora sono passato al caso serio in cui la stringa e' lunga qualche
migliaio di byte ebbene lo stesso comando di sopra non funziona,
ottengo un misero file vuoto. Da cosa puo' dipendere?
Per completezza vi riporto la definizione della classe:
typedef unsigned char BYTE; 
typedef unsigned char BIT;  
class bitstring {
      BYTE byte_buffer; 
      int  num_bit;     
      int  num_byte;    
   public:
      int  bit_offset;  
      int DIM;          
      unsigned char *stringa;
      bitstring(int) ;  
      ~bitstring() ;
      void  scrivi_bit(BIT) ;  
      BIT leggi_bit(int);      
      void scrivi_byte(BYTE);  
      BYTE leggi_byte (int);   
      void svuota_buffer();    
};
Ah, un ultima cosa, l'oggetto e' modificato all'interno di una 
funzione alla quale viene passato il puntatore, non dovrebbero
esserci problemi pero' da questo punto di vista, infatti ho 
provato in fase di debbugging a controllare se in effetti i byte
venissero scritti sulla stringa, e sembrerebbe proprio di si.
-- 
Nemesis at work

 ottengo un misero file vuoto. Da cosa puo' dipendere?
Prova ad aprire il file in modalità binaria.
Infatti (almeno sotto Windows) in un file aperto in modalità ascii
il carattere con codice ascii 26 viene interpretato come end-of-file.
Saluti   Manlio Perillo


Ho provato come dici tu con le righe:
  ofstream out("prova3.dat",ios::binary);
  out<<output2.stringa;
e ancora non funge, invece il classico...
  FILE * prova2;
  prova2=fopen("prova2.dat","w");
  fwrite(output2.stringa,sizeof(unsigned char),output2.num_byte,prova2);
  fclose(prova2);
...funziona perfettamente, come mai non riesco a fare lo stesso con gli
ofstream?
-- 
Nemesis at work

 ofstream?
Forse è un problema di terminatore: sei sicuro che la stringa termini con un
carattere 0 (\0)? Infatti nel secondo caso (in C) sei tu a dire alla
funzione fwrite quanti byte deve scrivere, e per questo motivo la stringa
viene scritta correttamente, nel primo, invece, cerca di
autodeterminare il numero di byte dalla lunghezza della stringa cioè a
partire dall'indirizzo puntato dal puntatore stringa scriverà tutti i byte
finché non troverà un carattere \0: insomma nel primo caso se inizia con il
carattere \0 non scriverà nulla sul file, mentre nel secondo caso scriverà
anche il resto. Comunque, se ti può essere di consolazione, ho provato la
tua classe e funziona :-) (sempre che non vi siano caratteri nulli
intermedi)
--
  Jerle Shannara
Per rispondere in email togli NO e SPAM
homepage 
http://utenti.tripod.it/jerleshannara

tua classe e funziona :-) 
Perchè avevi qualche dubbio ? ;)
(sempre che non vi siano caratteri nulli intermedi)
In che senso?? 
-- 
   _  __                  _    || L' estate svuota la mente e così
  / |/ /__ __ _  ___ ___ (_)__ || mi ritrovo senza uno straccio di
 /    / -_)  ' \/ -_(_-</ (_-< || idea  per riempire questo spazio
/_/|_/\__/_/_/_/\__/___/_/___/ || bianco ...

 aver richiamato la funzione bitstring::svuota_buffer() )
non e' piu' semplice usare
out.write( output2.stringa, output2.num_byte );
ostream_type&
write(const char_type* s, streamsize n);
Obtains characters to insert from successive locations of an array whose
first element is designated by s. Characters are inserted until either of
the following occurs:
n characters are inserted
 Inserting in the output sequence fails
In the second case the function calls the basic_ios member function
setstate(badbit). The function returns *this.
--
ciao
Massimo

 In che senso??
Nel senso che se ci sono caratteri nulli (cioè sempre 'sti benetti \0) nella
stringa, non funziona per le stesse ragioni di cui sopra.
Prova allora in questo modo: nella dichiarazione della classe in public
scrivi:
friend ofstream& operator<<(ofstream&, const bitstring&);
Poi l'implementi così:
ofstream& operator<<(ofstream& outstream, const bitstring& obj) {
 outstream.write((char*)obj.stringa, obj.num_byte);
 return outstream;
}
Adesso per poter scrivere su un file ti basterà fare:
ofstrem outfile("file_di_prova.txt");
outfile << oggetto_bitstring;
P.S. l'ho scritta basandomi su ciò che hai postato tu, senza provarla:
controlla bene se funziona!


Obtains characters to insert from successive locations of an array whose
[cut]
Beh direi che fa proprio al caso mio, Lunedě lo provo e ti faccio sapere.
-- 
   _  __                  _    || L' estate svuota la mente e cosě





 di ofstream senza guardare in quelle di ostream.
Non č semplicemente fare l'overload dello shift sinistro quanto la
possibilitŕ di accedere ad un membro privato della classe a cui non puoi
accedere con write.


 Beh direi che fa proprio al caso mio, Lunedì lo provo e ti faccio sapere.
Provato e funziona :)
Grazie. 
-- 
Nemesis at work

 accedere con write.
Se ti riferisci a num_byte non c'e' problema, nel frattempo avevo
modificato
la classe e l'ho reso membro pubblico, quindi posso usare anche write.
-- 
Nemesis at work

 Nemesis at work
E buon lavoro :-)


 E buon lavoro :-)
Thanks :)
 
-- 
Nemesis at work

posto particolari problemi di sicurezza.
Tieni presente che la tua casse molto semplice scritta oggi potrebbe
servirti anche domani e magari farla usare anche da altri, dopotutto
scrivere una funzione inline per ottenere un valore è velocissimo e
non influenza neanche negativamente le prestazioni della classe.
-- 
Marco Barisione (ICQ 84277092)


Si, infatti poi ho modificato la classe e ci ho aggiunto 
anche tale funzione.
-- 
Nemesis at work