venerdì 31 ottobre - 20:06
Google
 
Menù
  Home
  Come nasce IRC-Zone
  Glossario Informatico
  News
  I nostri progetti
  I nostri servizi
  Partners
  Diventa un Partner

IRC
  Cos'è IRC
  Storia di IRC
  Netiquette su IRC
  Emoticons
  Gergo della chat
  Lista Servers
  RFC 1459
  Shell Hosting

mIRC
  Cos'è il mIRC
  FAQ mIRC
  Configurazione mIRC
  Download mIRC
  Novità
  Script Stranieri
  Script Italiani
  MTS
  MTS Engine

mIRC Addon
  mIRC addon Audio
  mIRC addon SMS
  mIRC addon Grafica
  mIRC addon Utility
  mIRC addon Uso Bot

Client IRC
  Client IRC Linux
  Client IRC Mac
  Client IRC Win

XChat
  Cos'è XChat
  XChat per Win
  XChat per Unix

KVirc
  Cos'è KVirc
  FAQ KVirc
  Installazione su Linux
  KVirc Scripting
  KVirc per Mac
  KVirc per Win
  KVirc per Unix
  KVirc addon

Irssi
  Cos'è Irssi
  Download Irssi
  Download Moduli

Eggdrop/Windrop
  Cos'è un Eggdrop
  Download Eggdrop
  Configurazione Eggdrop
  Download Windrop
  Installazione Windrop

Tcl
  Download TCL
  Tutorial TCL scripting
  Documenti/Guide

BNC
  Cos'è un psyBNC
  Download psyBNC
  Configurazione psyBNC
  Download sBNC
  Configurazione sBNC

Linkaci!
footer

Credits
Somerights

footer

Statistiche
Ip: 54.89.68.105
Download: 796878 file
Totale: 1197295 MB

footer

Links amici
MF's IT User Essential Security Center



Basi di C++ - I/O nei files (I parte)

Autore: [Papero]Data: 2005-04-20
Modificato: 2007-01-26 Letture: 5674
Torna indietroStampa articoloInvia ad un amico

Lezione 10: I/O Nei files (Parte I)

Questo è un argomento un po' più avanzato di quelli trattati finora, ma penso che sia utile e che tornerà utile a molte persone. L'I/O nei files significa fondamentalmente leggere e scrivere files. Questa lezione tratterà solo i files di testo, cioè files che sono leggibili con un text editor, al contrario dei files binari (gli exe, per esempio). Non li tratterò molto, per esempio questa lezione non si occuperà della ricerca nei files o della lettura di dati specifici nei files. Sarà semplicemente incentrato sull'apertura, sulla scrittura e sulla lettura di files di testo. Non preoccupatevi, comunque, perché la lezione 11 tratterà meglio questo argomento.
Bene, come si fa a cominciare? I files hanno le loro funzioni sepcifiche da utilizzare, così come hanno il proprio tipo di dato, chiamato FILE (Ci sarebbe altro da dire su questo, ma adesso non è importante e verrà spiegato dopo, quando servirà). Il modo di usare il tipo FILE è lo stesso che si usa con gli integer, o con i float, o con i char:
FILE *newfile; //Crea un FILE chiamato newfile (non dimenticate che è //un puntatore)
Ora, non lo possiamo usare a meno che non ci sia un modo di dare a FILE(*newfile) un file a cui puntare. Questo modo esisite e si chiama stream. Questo significa che questo è il posto dove andrà l'output. Per dirigere *newfile verso un file, il comando da usare è FILE *fopen(const char *filename, const char *mode), che si trova in stdio.h. Esso restituisce semplicemente un puntatore ad un FILE, ma è abbastanza semplice da usare. per esempio:
FILE *newfile: //Crea un FILE chiamato newfile
newfile=fopen("c:\AUTOEXEC.BAT", "r"); //apre per la lettura il vostro file
//autoexec.bat e lo assegna
//a newfile

Sostanzialmente, fopen accetta due stringhe. Una è il nome del file, incluso il path e l'altra indica lo scopo per cui sarà utilizzato il file (il modo). In questo caso, la r denota che il file sarà aperto soòo per la lettura. Perciò, il file non può essere modificato fintanto che è aperto. Questà è probabilmente una buona idea, perché editare il vostro file autoexec.bat con garbugli non è una buona idea!
Come riferimento, ecco un elenco dei modi differenti con cui aprire un file:
r Apre in sola lettura.
w Crea un file per scrittura. Se già esiste un file con questo nome, sarà sovrascritto.
a Append; apre in scrittura alla fine del file, o crea il file se non esiste.
r+ Apre un file esistente in lettura e scrittura.
w+ Crea un nuovo file in lettura e scrittura. Se un file con questo nome esiste già, sarà sovrascritto.
a+ Apre per l'append; apre (o crea se il file non esiste) per aggiornare alla fine del file.
Tenete presente che ognuno di questi ha un uso differente, e che dovete scegliere il più appropriato per il vostro lavoro. Per ora, comunque, concentriamoci sulla lettura di files.
Ora, diciamo che volete stampare a schermo il contenuto del file autoexec.bat. Supponendo che vogliate fare un programma che faccia ciò, vi serve una funzione per leggere da un file. Ce ne sono molte e utili, ma per ora useremo int fgetc(FILE *stream)(Notare che restituisce un int, ma il range sarà ancora stampabile (è lo stesso dei char), definito in iostream.h). Fondamentalmente, fgetc otterrà il carattere successivo da un file che gli viene passato(cioè, lo stream che gli avete dato). Un esempio potrebbe essere il seguente codice per mostrare qualche carattere iniziale del vostro file autoexec.bat:

#include //Per cout
#include //per tutti le funzioni di i/o per i files
void main()
{
int count=0; //Solo una variabile per evitare la lettura perpetua del file.
FILE *afile; //Ci serve un FILE per puntare allo stream per
//l'accesso al file
afile=fopen("c:/AUTOEXEC.BAT", "r"); //Apre il fileautoexec.bat
//per leggerlo
//No, non so perché ci serve uno slash a rovescio.
while(count<10)
{
cout<<(char)fgetc(afile); //Da notare che fgetc restituisce un int,
//che può essere stampato.
//Notate l'uso di (char) per effettuare il 'typecast' all'integer
//restituito. Questo significa che lo rende un carattere stampabile
//dal numero. Ci sono altre informazioni su questo argomento nella
//lezione 11, che vi suggerisco di leggere.
//(Notare che i chars fondamentalmente convertono i loro numeri ASCII
//nel carattere stampabile appropriato. Per esempio 65='A' .
count++; //Non penso che debba venire letto all'infinito, giusto?
}
fclose(afile); //Sorpresa (niente paura, usatelo semplicemente per
//chiudere un file quando avete finito di usarlo).
//Semplicemente ponete il puntatore nello stream
//(il FILE)
}

Questo programma è abbastanza semplice, e non utilizza molte operazioni su files del C molto utili. Notate, comunque, che stampa solo pochi caratteri. E se volessimo stampare tutto il file? Bene, è qui che entra in gioco una cosa chiamata EOF(end-of-file). Si tratta fondamentalmente di un null che segnalala che è stata raggiunta la fine del file.
Quindi, come si potrebbe fare un programma che lo usa? Bene, fgetc recupera un carattere dal file, e restituirà EOF quando raggiunge la fine del file. Ora, è possibile usare un loop che controlla se l'ultimo carattere è uguale a EOF. Per esempio, CHARACTERREAD!=EOF. Questo restituirà true se CHARACTERREAD non è EOF.
Questo è quello che ho fatto io:
#include //Per cout
#include //per tutte le funzioni i/o dei files
void main()
{
FILE *afile; //Dobbiamo definire un tipo FILE per aprire un file
afile=fopen("c:/AUTOEXEC.BAT", "r"); //Apre autoexec.bat, solo in lettura,
//non lo scrive. afile è ora lo stream
//che punta al file autoexec.bat,
//ed è usato per fare operazioni con
//autoexec.bat
char c; //Senza un carattere per memorizzare le informazioni il programma
//non funzionerà
while(c!=EOF) //Controlla per vedere se il carattere appena letto è la fine
//del file
{
c=fgetc(afile); //Questo legge il carattere
//Notare che non è necessario effettuare il typecast del risultato di fgetc
//dato che viene automaticamente convertito in un carattere stampabile
//quando char c è un carattere.
cout< }
fclose(afile); //Per prudenza, chiudiamo il file!
}

Ok, alla fine siete riusciti a stampare! Bene, qual è la cosa successiva da fare? Perché non avere un programma che fa un backup del file autoexec.bat? Qui c'è una nuova funzione che vi servirà di aggiungere al vostro repertorio prima che questo programma possa essere fatto. La nuova funzione è fputc, definita in stdio.h.
int futc(int c, FILE *filethinghere);
Essenzialmente, restituisce il carattere che gli viene dato, oppure restituisce un EOF. Accetta un carattere come primo argomento, e un puntatore a uno stream (il FILE) come secondo argomento. Qui c'è un esempio su come usarlo:
fputc('A', newfile); //Scrive il carattere 'A' nel file puntato da newfile
Comunque, non dimenticate che questo non funziona sempre. Il file che lo stream punta deve essere aperto in scrittura, non solo in lettura. Di solito dovrete fare un append a un file, ma nel caso del nostro prossimo esempio vogliamo creare un nuovo file, e sovrascriverne uno vecchio.
Ora che abbiamo una funzione per scrivere in un file, perché non terminare il programma per il backup dell'autoexec.bat? Essenzialmente, useremo lo stesso loop della prima funzione, cioé controllando per vedere se è stata raggiunta la fine del file, altrimenti continuerà a stampare caratteri. Questa volta, comunque, i caratteri non verranno stampati sullo schermo. Invece, verranno stampati in un altro file (nell'esempio, backup.aut).
------------------------------------------------------------------------------ ATTENZIONE: Se avete un file che già si chiama backup.aut verrà sovrascritto! NON lanciate il programma di esempio se avete il file backup.aut nella directory del vostro compilatore! Altrimenti verrà sovrascritto. ------------------------------------------------------------------------------
#include //Necessario perle funzioni i/o dei files (inclusa fopen!)
void main()
{
FILE *autoexec, *backup; //Questa volta ci sono due files, AUTOEXEC.BAT
//e il file di backup
autoexec=fopen("c:\AUTOEXEC.BAT", "r");//Apre autoexec.bat in lettura
backup=fopen("backup.aut", "w"); //Crea (o sovrascrive)backup.aut in
//scrittura
char c; //Ci serve un buffer per leggere i caratteri
while(c!=EOF) //Controlla solo il raggiungimento della fine del file
{
c=fgetc(autoexec); //Legge un carattere da autoexec.bat
fputc(c, backup); //Scrive un carattere nel file di backup!
}
fclose(autoexec);
fclose(backup); //Chiude i files per terminare!
}

Wow! E' un programma che può essere utile. Siete liberi di usarlo quando volete. Ricordatevi solo come funziona. Non pensate che questa è la fine delle informazioni sull i/o dei files. C'è dell'altro, ma per ora dovrebbe essere sufficiente per stimolare il vostro appetito.
Oh, e potete usare fputc anche per scrivere l'input dell'utente in un file! penso che ve l'eravate immaginato!


 

Branzilla Contest Redeem

Links utili

Newsletter
Iscriviti
Cancellati

Ci sono 41 iscritti

In rilievo..
  JackSMS v3
  Venom Script Lite

Documenti/Guide
  I Social Network
  Sicurezza in rete
  Cos'è SSL
  FAQ Bot
  Documenti su IRC
  FAQ Ident
  RFC 2810
  RFC 2811
  IRCx RFC

Informatica libera
  Gli Hoaxes
  Hoaxes report
  Documenti vari
  CensorWare
  Windows
  Linux

mIRC Scripting
  Codice ASCII
  Snippet mIRC scripting
  Tutorial mIRC scripting
  Dll per mIRC
  Utilities

IRCd
  Cos'è un IRCd
  Download Unreal
  Download Hybrid 6
  Download Hybrid 7
  Download Ultimate
  Download Bahamut
  Configurazione IRCd

IRC Services
  Cosa sono i Services
  Download Anope
  Download Epona
  Ircservices 5.0
  Ircservices 5.1
  Configurazione Epona
  Configurazione Anope
  Comandi ChanServ
  Comandi NickServ
  Comandi MemoServ

NeoStats
  Cosa sono i NeoStats
  Download NeoStats
  Configurazione NeoStats
  Download Moduli

IPv6
  Cos'è IPv6
  IPv6 su Win2000
  IPv6 su WinXP
  IPv6 su Linux
  IPv6 su mIRC e Xchat

Programmazione
  Tutorial C++
  Tutorial C
  Compilatori C/C++

Altro
  Contatti
  Banners Gallery

RSS Feed




Progetti
Starlight
IRCHippo

Validato CSS
Sito interamente sviluppato in PHP
MySQL
©2004+ IRC-Zone | Webmaster | Sitemap
Created by Cesare 'Kaesar83' Lasorella
Designed by Manuel 'erkokki' Cabras
IRC-Zone non è responsabile del contenuto dei siti linkati
Pagina creata in: 0.088 sec con 27 queries
Spampoison
Sviluppato con Notepad++
website monitoring service