Newsgroup: it.comp.programmare.win32
Titolo: Stringhe AIUTOOOOOOOOOOO

Come posso fare affinché una stringa venga ricercata e modificata
all’interno di un file file?
Grazie 1000,
GB
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 all interno di un file file?
Dipende da quale linguaggio di programmazione vuoi usare (supponendo
che "file file" sia un errore di battitura e non un nuovo concetto
informatico a me ignoto;-), da quale interfaccia utente vuoi (GUI,
testo, web, ...?), dai dettagli delle specifiche (ad es., vuoi
cambiare solo la prima occorrenza o tutte?  e` un file di testo o
un arbitrario file binario?  Le stringhe vecchia e nuova possono
contenere caratteri di fineriga o sono solo porzioni di una riga?
le distinzioni minuscole/maiuscole devi gestirle, e se si` come?
Devi gestire possibili anomalie ed errori, e se si` come? &c &c...).
Ad esempio se tutti questi "dettagli" di specifica si semplificano
al massimo, un programma con UI di testo che opera su di un file
di testo quando lo invochi con una sintassi del tipo (al command
prompt):
    C:\> python cambia.py vecchia nuova \MyDocuments\filefile.txt
potrebbe essere il seguente cambia.py:
import sys, fileinput
__, vecchia, nuova, nomefile = sys.argv
for riga in fileinput.input(nomefile, inplace=True):
    print riga.replace(vecchia, nuova),
Ad ogni complicazione che vorrai portare, la mole del programma
crescera`, da queste 4 righe magari a 44, o 444, o ... -- dipende
da te!-).  A parte l'eventuale GUI (o la scelta di linguaggi
solo-Windows, come VBasic, invece di altri cross-platform, come
Python, Perl, C, C++, Java, ...), il problema pare avere poco a
che vedere con Win32, quindi postare (con specifiche molto, ma
molto, ma *MOLTO* piu` dettagliate, magari...) sul piu` generale
newsgroup it.comp.programmare potrebbe essere + proficuo.
Alex

 Alex


 occorrenza)?
Se la nuova stringa e` della stessa lunghezza della vecchia hai
relativamente pochi problemi: puoi aprire il file con "r+", leggerlo
(ad es una riga alla volta se sai che la stringa vecchia deve essere
entro una riga [cosa che non hai ancora precisato]), quando trovi
per la prima volta la stringa vecchia entro la riga corrente la
rimpiazzi con la nuova, fseek, e scrivi.
Ma se la stringa deve cambiare lunghezza questo e` impraticabile.
Quello che devi fare invece in questo caso e` leggere il file
vecchio e scriverne uno nuovo (con l'unico cambiamento suddetto
ma altrimenti copiando pari parti), e alla fine rimuovere il
file vecchio sostituendolo con quello nuovo.  Questo indica,
naturalmente, che la struttura-dati scelta e` pessima se questo
tipo di operazioni e` frequente.
Alex

ma altrimenti copiando pari parti), e alla fine rimuovere il
file vecchio sostituendolo con quello nuovo.  Questo indica,
posso caricare una stringa lunga quanto i caratteri in esubero, e usarla per
riscrivere un pezzo alla volta il file dal punto in cui inizia la variante
evito di usare due file, no?

Antonio wrote:

Tecnicamente e` possibile.  A parte il fatto che la programmazione di
gestione generalizzata dei buffer e` curiosamente prona all'errore,
la garanzia di disastro assoluto (perdita certa dei dati) se l'Enel 
decide di andare in blackout mentre stai riscrivendo il file, e le
prestazioni forse (invero, probabilmente) pessime.
Suggerimento: per cautelarti almeno contro l'ultima possibilita`,
fai programmini-giocattolo con alcuni parametri.  Il primo programma
prepara un file fatto di N blocchi ciascuno di M caratteri (binario 
o testo a seconda di quel che intendi usare nell'applicazione) e
serve sostanzialmente per partire da un punto di riferimento noto
(semplificato dal fatto che tutti i blocchi sono equali).  Il
secondo programma copia un tale file in un altro dove pero` il
blocco K viene "allungato" a M+Z caratteri diversi.  Il terZO 
programma esegue l'allungamento "sul posto", come tu pensi di fare.  
Il quarto controlla che il file risultante sia perfettamente corretto
(K-1 blocchi di M caratteri come all'inizio, poi uno di M+Z
caratteri come da allungamento, infine N-K altri blocchi di
M caratteri come all'inizio) e serve come verifica del secondo e
del terzo.  La parte piu` interessante dell'esercizio e` misurare
le prestazioni del secondo e del terzo programma a seconda della
piattaforma, del tipo di filesystem (nulla di piu` facile che non
osservare prestazioni diverse su FAT32 e NTFS, ad esempio), e dei
parametri N, M, K e Z.  Puoi usare qualsiasi linguaggio piu` ti
comodi, visto che le prestazioni dovrebbero essere limitate dall'I/O,
non certo dalla CPU, e quindi, assembly, C, Python, o altro, poco
dovrebbe cambiare in ogni caso.  L'esercizio dovrebbe comunque
essere istruttivo relativamente alla gestione di file e blocchi.
Se scrivi questi programmi in C (la cosa importa solo per il
terzo), ricorda una regola di base: per aprire un file in lettura
e scrittura senza distruggerne il contenuto precedente, usa come
opzione della open "r+" ("r+b" per file binari); quando passi
dalla lettura alla scrittura o viceversa DEVI fare un fseek sul
file -- questo dice lo standard ISO per il linguaggio C, questo
richedono le tipiche implementazioni delle funzioni di stdio.h,
e questo tipicamente e` comunque intrinseco alla logica di un
tipico programma che deve leggere E scrivere lo stesso file sul
posto (ma anche se la logica intriseca di un dato programma non
lo richiede, comunque dovrai inserire un fseek per soddisfare
lo standard e la tipica implementazione di stdio.h).
Potro` sbagliare, ma, secondo me, quando avrai finito questo
esercizio e avrai visto le misurazioni dei tempi per una gamma
rappresentativa di parametri, avrai capito benissimo perche`,
in pratica, i programmi che usano lettura e scrittura "sul posto"
lo fanno quasi solo con file binari composti di blocchi di
dimensione fissa -- anche a prescidere dai rischi di blackout.
Alex