Newsgroup: it.comp.lang.c++
Titolo: leggere e scrivere da file e calcoli bit a bit

Vorrei fare la seguente cosa:
-Aprire file1 in lettura
-Aprire file2 in scrittura
-Leggere 16 bit da file1
-Leggere i 16 bit successivi da file1
-Trovare quali bit sono cambiati dalla prima lettura alla
seconda e scrivere 0 se il bit non e' cambiato e 1 se e' cambiato
-Scrivere i 16 bit ottenuti in file2
Ora, le domande che mi pongo sono:
-Mi date delle dritte sul modo migliore per fare questo?
-Mi conviene usare i <bitset> ?
-Si puo' fare un C++ standard, vero?
--
Gerolamo

 -Si puo' fare un C++ standard, vero?
Al netto del problema dei "16 bit", che a rigor di standard non
mi pare sia risolubile, direi proprio di si`.
Alex

 [CUT]
Dandogli tutto il programma pronto non lo aiuti proprio ad imparare...
-- 
Luc.

 #include <limits>
--
Ciao
Gaetano
--
#exclude <windows>
printf("\t\t\b\b\b\b\b\b");.
printf("\t\t\b\b\b\b\b\b");

 > #include <limits>
Questo certamente no!  Se hai proprio un'allergia per i .h
dovrai almeno includere <climits>, di cui 18.2.2 sub 2 dice
"i contenuti sono gli stessi dello Standard C Library
header <limits.h>".  Includendo <limits> invece non puoi
garantire di ottenere la definizione di CHAR_BIT.
Personalmente, mi pare che si rischi confusione fra gli
include di <limits> e <climits> e quindi sia meglio invece
includere <limits.h>, su cui si corrono meno rischi di
trovare incomprensioni nel lettore/manutentore del codice.
Alex

"Luc" <XXX...@katamail.comXXX> wrote in message
news:MPG.16af5724e...@news.enter.it...

Forse si`, forse no.  Considera che non ha specificato le parti piu`
delicate (e quindi sulle quali c'e` piu` da imparare), come la gestione
dei casi d'errore...
Alex

 garantire di ottenere la definizione di CHAR_BIT.
Nessuna allergia non ho mai usato limits.h ma limit e non
ho mai incotrato il problema di non avere definito CHAR_BIT.
In ogni caso preferisco evitare di includere i .h se ci sono gli
equivalenti senza, e il fatto che l'equivalente di limits.h non
sia limit ma climit mi sembra da matti da legare, ma se
hanno deciso quelli dello standard....


 mi pare sia risolubile, direi proprio di si`.
Era piu' o meno il mio dubbio, comunque se mi dici che cosi'
funziona sulla stragrande maggioranza delle piattaforme (e,
sostanzialmente, mi interessano solo PC, Mac e simili...) mi fido :-)
Gia che ci siamo qualcuno mi saprebbe indicare dove trovare info
sull'accesso in binario ai file, visto che Stroustrup e Lippman ne
parlano solo vagamente? (oppure ditemi dove ne parlano...
sono stordito e magari non l'ho trovato io...)
Intanto grazie.
--
Gerolamo

 Quando sono utili i bitset, allora?
Non per l'I/O binario, direi, che e` comunque definito solo
su byte (caratteri).
Alex

 hanno deciso quelli dello standard....
In pratica, nelle implementazioni ancora assai acerbe delle
librerie ISO Standard C++, tu #includi una cosa e te ne vengono
dentro N (comprese spesso quelle che NON dovrebbero, come ad
esempio CHAR_BIT in questo caso...).
L'astrusa complicazione del C++ e` tale che a tutt'oggi non
*UN* fornitore dichiara di supportare l'intero standard ISO/IEC
14882-1998.  Considerando il tempo che e` passato, la stabilita`
dello standard stesso per un tot prima del suo ufficiale
rilascio nel 1998, e i soldini che girano su queste cose (che
dovrebbero sicuramente incentivare!), e` un triste commento.
Alex

 sia limit ma climit mi sembra da matti da legare, ma se
L'equivalente di *ogni* header C old-style antepone la "c"
davanti (vedi stdio.h -> cstdio, stdlib.h -> cstdlib, ecc..).
A me non sembra un'astrusita' cosi' grande.
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

     const int nchars = 16/CHAR_BIT;
ma se CHAR_BIT fosse ad esempio 32 o 64, nchars varrebbe 0, e se fosse 
7, varrebbe 2, ma conterrebbe al max 14 bit...
oppure CHAR_BIT _deve_ essere 8?

 wrote in message
news:1670676.r...@iol.it...

CHAR_BIT in teoria puo` essere quel che vuole (ALMENO 6 o 7, mi pare,
a norma di standard ISO C, ma non ho quest'ultimo sotto mano).
Come ho detto, la specifica "leggere 16 bit" e` comunque soddisfacibile
solo se CHAR_BIT e` un sottomultiplo di 16.  (Se la specifica e` di
leggere ALMENO 16 bit o AL MASSIMO 16 bit, e` ovviamente un caso assai
diverso, ma nel mio post ho implementato le esatte specifiche postate).
Come ho pure detto, quel che ho postato non fa controllo di errori.  Un
possibile errore e` ovviamente nchars*CHAR_BIT != 16, e, come tanti
altri, potrebbe (forse dovrebbe...) essere verificato.  Per questo tipo
di controlli, l'ideale e` usare assert.
Alex

 Come ho pure detto, quel che ho postato non fa controllo di errori. 
misteri di usenet: per me il post a cui ho risposto finiva a  
for(int j=0; j<nchars; ++j)
        file2.put(buferresult[j]);
allora mi sono riletto il thread, ma niente. dato che AM non sembra uno 
che le spara cosi', ho quindi cercato il post su un altro server ed e' 
spuntato il resto... mah.
Sono pienamente concorde con quanto detto, anche se al posto di assert 
di solito uso un paio di funzioni template 
template <Typename Tipo>
bool assure_pre<Tipo> (const Tipo& variabile, Tipo condizione); 
template <Typename Tipo>
bool assure_post<Tipo>(const Tipo& variabile, Tipo condizione);
(eiffel docet)
che all'occorrenza specializzo su tipi particolari
Saluti

 template <Typename Tipo>
typename e' anche corretto

 a norma di standard non mi pare che si possa garantirlo.
Io ho lavorato con dei DSP che avevano char di 32 bits (cosi' come
erano di 32 bits int, short e long).  E' difficile che il programma
venga eseguito su piattaforme cosi' esotiche, ma un controllo perche'
nchars sia almeno uno ce lo metterei.
-- 
Maurizio Loreti  - Linux Is Not UniX -  
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

 su byte (caratteri).
mmm...
Allora, ricominciamo: devo leggere dei file wav, per cui
parto dal presupposto che siano a 16 bit e di lavorare su
piattaforma PC-Mac, poi devo farci dei conti sopra, e scrivere
quello che ho ottenuto in un altro file.
E' giusto quindi che ci acceda in binario?
--
Gerolamo

 a norma di standard ISO C, ma non ho quest'ultimo sotto mano).
In C++:
1 ==sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)
1 <= sizeof(bool) <= sizeof(long)
sizeof(char) <= sizeof(wchar_t) <= sizeof(long)
sizeof(float) <= sizeof(double) <= sizeof(long double)
sizeof(T) == sizeof(signed T) == sizeof(unsigned T)
inoltre
char deve essere almeno 8 bit
short deve essere almeno 16 bit
long almeno 32 bit
Mi hanno detto che in C99 e' lo stesso ed è scritto nel paragrafo
5.2.4.2.1 dello standard.
Non ho lo standard (nè quello del c nè quello del C++), per cui
non posso controllare, ma mi fido.
--
Gerolamo

 non posso controllare, ma mi fido.
Ho quello del C++ e non dice nulla del genere. Dice solo che il tipo
char deve essere abbastanza grande da supportare il set di caratteri di
compilazione. E per farlo bastano e avanzano 7 bit per il char.
--
Andrea Ferro
IHHC - Member of HT-Group    DVD Authoring operator    Fan of I.Asimov
Brainbench C++ Master:
http://www.brainbench.com/transcript.jsp?pid=2522556

 IHHC - Member of HT-Group    DVD Authoring operator    Fan of I.Asimov
... e allora beccami da dove viene la citazione:
"Dati insufficienti per risposta significativa"  (Isaac Asimov)
Ciao!
--
Gerolamo

(bensi` Lippman-Lajoie).
Non ha molto senso dire che é un libro é peggio di un altro perché non
spiega un argomento che in fondo non é strettamente legato con il c++ 
(magari se si fosse trattato di un libro dedicato all'informatica in
generale sarebbe stato diverso).
Il Ghenio
---------
// TODO: Place your ass here

 "Dati insufficienti per risposta significativa"  (Isaac Asimov)
Mumble. Dovrei fare una bella ricerca! Per ora provo a spararla "per
istinto": uno dei "brevi" sul Multivac (nota: potrebbe persino essere un
titolo!).
--
Andrea Ferro
IHHC - Member of HT-Group    DVD Authoring operator    Fan of I.Asimov


spiega un argomento che in fondo non é strettamente legato con il c++ 
Che vuol dire "non e' strettamente legato col C++" ?
Visto che e' previsto che i file possano essere aperti con
due modalita' diverse, perche' nasconderlo al programmatore
che cerca di apprendere come aprire un file in C++ ?
-- 
Andrea Laforgia - walkietalkie(at)
libero.it
"Meglio cieco che negro" (Stevie Wonder)

 titolo!).
no... il titolo è "L'ultima domanda" ("The Last Question")
Direi.. da leggere. :-))
--
Gerolamo

 Direi.. da leggere. :-))
Letto, ovviamente. Anche se non ricordo in quale raccolta.
Solo che da questo a essere certo che la risposta fosse proprio quella e
non solo qualche cosa di simile e che invece quella risposta fosse data
in un altro contesto ce ne passa. Per non parlare del ricordare a
memoria tutti i titoli dei brevi (mi manca persino la memoria per i
titoli esatti di tutti i romanzi, figurati i brevi!).
P.S.: non cercarmi su it.fan.asimov che l'ho sganciato da tempo per ...
mancanza di tempo.


che cerca di apprendere come aprire un file in C++ ?
Infatti non é nascosto , nessuno ha detto che lo é, compra l'edizione
italiana del libro di Stroustrup e vai a pagina 733, scoprirai che
l'autore elenca tutte le modalità di apertura di un file compresa
ovviamente quella binaria.


 Infatti non é nascosto , nessuno ha detto che lo é, 
Nel mio messaggio mi riferivo alla frase di Alex:
"binario" (non importante su Unix e simili, ma si` su altre
piattaforme come Mac e Win) e` dato in fase d'apertura dal
flag binary.  Sembra quasi impossibile che Stroustrup non
nomini quest'ultimo, ma se cosi` e`[...]".
Il testo di Stroustrup ce l'ho, ho anche la pagina 733.


Ok.
Magari postate poi qualcosa anche qui per chi non ha tempo di seguire
altri newsgroup, anzi a proposito di mancanza di tempo ora devo andare
a scuola :-(
-- 
Marco Barisione (ICQ 84277092)

 a scuola :-(
Certo. Se risolvessero in maniera chiara e definitiva la questione
qualcuno poi riporterebbe la cosa. Mi par di capire che quei NG sono
seguiti regolarmente da A.Laforgia e N.Musatti. Io li seguivo tempo
addietro, poi li ho sganciati per mancanza di tempo, ora li ho
riagganciati ma sono *pesantemente* filtrati nel senso che non ho il
tempo di seguirli per cui mi limito a uno o due thread, morti questi
(nessun post in alcuni giorni) ne scelgo uno o due nuovi e cosi' via.
Comunque tranquilli che esiste una "rappresentanza" di questo NG anche
in quelli (e viceversa).
--
Andrea Ferro
IHHC - Member of HT-Group    DVD Authoring operator    Fan of I.Asimov
Brainbench C++ Master:
http://www.brainbench.com/transcript.jsp?pid=2522556
This post express personal opinions which may or may not be the opinons
of the
company(s) I work for. I speak for myself and for myself only.

 ha scritto nel messaggio
news:6k518.32857$aD.12...@twister2.libero.it...
: Vorrei fare la seguente cosa:
: -Aprire file1 in lettura
: -Aprire file2 in scrittura
: -Leggere 16 bit da file1
: -Leggere i 16 bit successivi da file1
: -Trovare quali bit sono cambiati dalla prima lettura alla
: seconda e scrivere 0 se il bit non e' cambiato e 1 se e' cambiato
: -Scrivere i 16 bit ottenuti in file2
:
: Ora, le domande che mi pongo sono:
: -Mi date delle dritte sul modo migliore per fare questo?
: -Mi conviene usare i <bitset> ?
: -Si puo' fare un C++ standard, vero?
:
: --
: Gerolamo
:
:

 cmq leggere i manuali prima di chiedere
Beh... I manuali che ho non mi hanno molto soddisfatto, da questo
punto di vista.
Tra l'altro purtroppo adesso ho veramente poco tempo da dedicare
a questo problema... uff... le idee migliori (!!!) mi vengono sempre
sotto esame :-((
comunque grazie
--
Lo spam è un problema! Informati su: 
http://www.collinelli.net/antispam
Abbonati a un ISP decente che utilizzi tecniche per combattere lo spam
Non usare una mailbox e-nonima. Se hai paura dello spam usa servizi come
Despammed, Sneakemail, 
Vene.dave.it
, ecc...   ----    Ciao, Gerolamo.

[Il Ghenio]
Perché in quel contesto il termine "spiegare" era inteso nel senso di
descrivere la differenza fra un file binario ed uno non binario,
argomento che non é strettamente legato al c++(lo ripeto ancora).
A questo punto direi comunque di troncare quest'inutile discussione.
