C TUTORIAL (parte I)

eZine lover (@eZine)

Published in 

bakunin

 · 2 years ago

BAKUNIN
bakunin@meganmail.com

Ave a tutti quanti voi da Bakunin.

----->>>Programmazione in C.

INDICE

1. Occorrente
2. Librerie, variabili e struttura base
3. Input ed Output (Scanf e Printf)
4. Giochi vari con le variabili
5. Spiegazione generale dei puntatori
6. Array
7. Funzioni
8. CICLI:
• a) IF
• b) WHILE
• c) DO
• d) FOR
9. Break
10. Continue
11. Strutture
12. File
• a) fopen
• b) fprintf
• c) fclose
• d) fscanf
• e) fwrite
• f) fread
• g) putc e getc
• h) salvare dati e ricercarli
13. Commenti e impaginazione

1. Incominciamo subito con l'occorrente necessario

1. Un qualsiasi editor (Blocco note di Windows, VI di linux, Editor di DOS, tutto quello che volete...);
2. Un compilatore, cioè quel programma che ti permette di trasformare un file.c in un file.exe. (Si possono trovare a centinaia su INTERNET!). Io personalmente uso il gcc di linux [MESSAGGIO PROMOZIONALE: Passate a Linux, si è più sicuri, ci sono già tutti i tipi di compilatori di questo mondo per tutti i linguaggi di programmazione, è tutto gratuito, e gliela mettete in CUL_O a Bill!!], ma ho visto che sul sito www.programmazione.it ne trovate a bizzeffe! APPUNTO DI SCREENER_IT: trovate un compilatore per C sotto Windows nella sezione Programmi del Tank Commandos Web Site (http://go.to/tankcommandos)
3. Non c'è nessun punto 3!

INCOMICIAMO!!!

Aprite il vostro editor e scrivete:

-------INIZIO------ 

main(){ 
} 

-------FINE-------

Questo è il nocciolo di tutti i programmi C. Come potete vedere questo programma, compilato non fa nessun'operazione. Infatti quello che ho creato è solo il nocciolo, la procedura base. All'interno di questa poi si dovranno inserire ciò che vogliamo che il programma faccia.

Per far fare qualcosa al programma è necessario inserire al suo interno un collegamento alla libreria che contiene le operazioni e il loro funzionamento. Esistono vari tipi di librerie: Stdio.h è una di queste. Questa in particolare è quella che utilizeremo noi nel prossimo esempio:

------------------ 
#include <stdio.h> 

main(){ 
printf("CIAO MONDO!!!"); 
} 
------------------

Cosa abbiamo fatto?
Semplice. Con il comando #include colleghiamo appunto, come sopra detto, la libreria <stdio.h>. Poi c'è il "main" che è appunto la procedura centrale, seguito da (). Queste due parentesi ora sono vuote ma successivamente scopriremo che possiamo anche riempirle. { Indica che da qui in avanti c'è l'elenco delle operazioni. Questo elenco si conclude con }.

Tutto ciò è molto simile al PASCAL quando si fa BEGIN ed END.

Come operazioni abbiamo inserito printf("CIAO MONDO!!!") il che vuol dire: stampa sullo schermo la scritta contenuta fra le due virgolette (nel nostro caso CIAO MONDO!!!).

Tutte le operazioni devono ASSOLUTAMENTE FINIRE con ; .

Ora mando in esecuzione il programma:

c:\>prova.exe

Dovrebbe comparire una roba simile a questa! Non è vero?

c:\>prova.exeCIAO MONDO!!!c:\>

Questo è successo perché non abbiamo mandato a capo la stringa CIAO MONDO!!!.
Questo si ottiene facendo:

printf("\n\rCIAO MONDO!!!\n\r");

Cosa ho fatto? Ho inserito le opzioni \n e \r alla stampa della scritta. Il risultato sarà:

c:\>prova.exe 

CIAO MONDO!!! 

c:\>

Ci siamo riusciti!!

ORA BECCATI 'STA TABELLA SULLE ALTRE OPZIONI POSSIBILI DI IMPAGINAZIONE CON PRINTF:

------------------------------------------- 
| \n   | Nuova linea                      | 
| \t   | Tab                              | 
| \b   | Spazio indietro                  | 
| \r   | A capo                           | 
| \'   | Inserisci l'apostrofo            | 
| \"   | Inserisci le virgolette          | 
| \\   | Inserisci lo \                   | 
| \d   | Carattere con codice Ottale      | 
| \dd  | Vedi sopra                       | 
| \ddd | Vedi sopra                       | 
| \xh  | Carattere con codice esadecimale | 
| \xhh | Vedi sopra                       | 
| \e   | Escape                           | 
| \v   | Tab verticale                    | 
-------------------------------------------

Con questa tabella puoi incominciare a posizionare il testo dove ti pare.

Ora un altro esempio:

-------INIZIO---------- 
#include <stdio.h> 

main(){ 

  int numero; 

  numero=3; 
  printf("Il numero perfetto è %d, così è detto dai greci!", numero); 

} 
-------FINE-----------

Spiegazione:

Con int inizializzo la variabile numero. Cosa vuol dire inizializzare? Vuol dire che da ora in avanti esisterà per il programma una variabile numero che farà determinate operazioni. Con numero=3 dò alla variabile numero il valore di 3. Infatti = serve per attribuire un valore ad una variabile. Questo è fattibile in PASCAL con := .

Per quanto riguarda l'operazione printf("Il numero perfetto è %d,... Potevo benissimo scrivere ("Il numero perfetto è 3... Ma non avreste imparato niente di nuovo! Cosa ho fatto? Ho detto attraverso il comando %d di andare a prendere il valore della prima variabile dopo le virgolette e di inserirla nella scritta.

"il numero perfetto è %d, così è detto dai greci!", numero 
       |         | 
       --------------------------------

RISULTATO:

Il numero perfetto è 3...

Si sono altre possibilità di inserire variabili.
A proposito di ciò beccati la tabella:

-------------------------------------------------- 
| int    | da -32767 a 32767                     | 
| long   | da -2147483647 a 2147483647           | 
| float  | da 3,4 * (10**-38) a 3,4 * (10**+38)  | 
| double | da 1,7 * (10**-308) a 1,7 * (10**+308)| 
| char   | Un carattere                          | 
--------------------------------------------------

int lo abbiamo già usato

long si usa con int (ES: long numero;)

Float pure

Double perché dovrebbe essere diverso dagli altri 3?

Char questo è diverso!
Char si usa per i caratteri. (ES: char carattere;). Il carattere però può essere messo in due modi diversi:

1. Sotto carattere ascii (carattere='A'; Notate che bisogna usare l'apostrofo e non le virgolette!)
2. Sotto numero ascii (cioè quella combinazione che dà la lettera. ES: carattere=65; Poichè se fate Alt+65 compare A!).

EX CLARO?

Parliamo ancora di numeri!
Se vogliamo aumentarli o diminuirli?
Semplice: Non abbiamo al variabile numero inizializzata. Basta fare:

numero++; Aumentato di 1 
numero+=2; Aumentato di 2 
numero+=3; Aumentato di 3 
numero-=3; Diminuito di 3 
...

Parliamo ancora di %d! %d riporta il valore numerico della variabile numero
Ma se noi volessimo il corrispettivo valore ascii dovremmo fare %c.

Ora beccati un esempio su questo:

---------INIZIO------------ 
#include <stdio.h> 

main(){ 

  int numero; 
  printf("\n\rINSERISCI UN NUMERO:"); 
  scanf("%d",&numero); 

  printf("\n\rTU HAI INSERITO IL NUMERO %d",numero); 
} 
---------FINE------------

SPIEGAZIONE:

Termini nuovi.
SCANF riceve un input dalla tastiera. Aspetta che tu digiti qualcosa. Quello che tu digiti, che deve essere in formato numerico (perché abbiamo inserito %d!) verrà immagazzinato nella variabile inizializzata col nome di numero.

Dopo di che viene stampata con il comando printf nel modo che abbiamo già visto.

Ora un altro esempio.

---------INIZIO------------ 
#include <stdio.h> 

main(){ 

  char numero; 
  printf("\n\rINSERISCI UN NUMERO:"); 
  scanf("%d",&numero); 

  printf("\n\rTU HAI INSERITO IL NUMERO %d CHE SOTTO FORMA DI LETTERA E' %c",numero,numero); 
} 
---------FINE------------

SPIEGAZIONE:

Inizializzo una variabile di carattere chiamata numero. La richiedo all'utente nel modo spiegato sopra. Poi la stampo sia come carattere ascii che come carattere numerico.

Ma cos'è quella &? Questo simbolo serve per specificare la locazione di memoria in cui deve essere inserito il valore che arriva dalla tastiera. E' la parte della memoria che deve occupare. Io posso sin dall'inizio dire che quella variabile deve occupare parte della memoria e per far ciò devo usare i puntatori. Questi cosi detti puntatori non sono altro che delle variabili che hanno già una collocazione precisa.

Per crearli basta fare:

int *numero;

Da questo momento la variabile numero è un puntatore. Il puntatore può contenere una variabile e quindi è lecito fare:

int *A; 
int B; 
A=B;

ed è pure lecito fare:

*A=3;

-------------FINE PRIMO TEMPO-----------------

-------------INIZIO SECONDO TEMPO---------------

Array è un'insieme di variabili.
Cosa vuol dire? Se io inizializzo una variabile posso inserire un valore in quella variabile.
Un array è un tipo di variabile che può accettare dentro se più variabili.
Quindi una variabile semplice è come una casella.
Una array è un insieme di caselle.
Queste possono essere così:

1 2 3 4 5 6 7 8 9 ... Quindi su una sola linea. 

1.1  2.1  3.1  4.1 ... 
1.2  2.2  3.2  4.2 ... 
1.3  2.3  3.3  4.3 ... 
1.4  2.4  3.4  4.4 ... 
... 
...

A tabella.

Queste sono i tipi di array.

Come si fanno a crearle? Così:

int numero[50]; ovviamente 50 è il numero di variabili che array contiene.

o a tabella:

int numero[30][30];

Anche 30 è un numero di mia invenzione.

Per utilizzarle basta fare:

numero[0]=3; 
numero[1]=456675; 
...

e così via dicendo.

Se io lo inizializzo come contenete 30 variabili, la priva sarà [0] e l'ultima [29].
Ciò vuol dire che si incomincia a contare a 0 e non da 1!

Ora vi spiego come creare delle funzioni esterne a quelle principali.
Per chi conosce il PASCAL sa già a cosa mi sto riferendo, gli altri seguano la spiegazione.

Spesso, quando creo un programma complicato, con molte operazioni, non è semplice riuscirsi a districarsi fra tutte queste. Se io divido queste operazioni in pacchetti e poi li richiamo quando mi servono, risparmio tempo, spazio e possibilità di errore.

Le funzioni sono dei pacchetti di operazioni che io richiamo con un semplice comando.
Vediamo un esempio:

---------INIZIO-------------- 
#include <stdio.h> 

int doppio(int numerob); 

main(){ 
int numero; 
scanf("%d",numero); 
printf("\n\rIl doppio del numero %d è %d",numero,doppio(numero)); 
} 

int doppio(int numerob){ 
return numerob*2; 
} 
----------FINE------------

SPIEGAZIONE:

Con la riga int doppio(int numerob); dico che in questo programma esiste una funzione chiamata doppio e che per avviarla bisogna inserirgli un numero.

Vi ricordate quando vi dicevo che main aveva le due parentesi vuote ma potevo anche riempirle? BENE, sostituite alla parola main la parola doppio e vedrete che avete le parentesi () riempite dalla parola numerob.

Poi parte la solita funzione principale detta main.
Questa inizializza una variabile detta numero e lo richiede all'utente. Questo inserisce il numero e lei trova il doppio facendo queste operazioni:

"Il doppio del numero %d è %d",numero,doppio(numero) 
       |    |   |          | 
        ----|-----         | Quando interpellata, la funzione doppio parte 
            |              | con allegato l'opzione numero. 
            ----------------  Quindi il numero inserito dall'utente entra 
                              nella funzione doppio e qui viene moltiplicato 
                              per due.

La funzione return rimanda il risultato al suo posto moltiplicandolo per due.

Come vedi anche la funzione doppio viene aperta con { e chiusa con }.

EX CLARO?

Ora passiamo ai cicli. Per quanto riguarda i cicli ce ne sono vari tipi:

-------------------------------------- 
| IF    | SE x ALLORA y ALTRIMENTI z | 
| WHILE | FINO A QUANDO x FAI y      | 
| DO    | FAI x FINO A CHE y         | 
| FOR   | PER x VOLTE FAI y          | 
--------------------------------------

IF

Quando io imposto un if penso che il risultato possa essere vero o falso. Per quanto riguarda C, ma come è anche per il PASCAL e l'ASSEMBLER e tutti gli altri principali linguaggi di programmazione, non esiste vero o falso, ma esiste orrore 0 ed errore 1.
Se si verifica l'errore 0 vuol dire che l'operazione si è verificata.

Schema del funzionamento:

IF (funzione()) funzione();

che con un esempio vuol dire:

if (numero>100) printf("Il numero è maggiore di 100!");

Se il numero è maggiore di 100 ci sarà un errore 0 e quindi comparirà la scritta altrimenti non comparirà niente.

Complichiamo un po' le cose: 

if (numero>100){ 

printf("Il numero è maggiore di cento!!"); 
} 
else { 

printf("Il numero non è maggiore di cento!"); 
}

Cosa ho fatto?
Ho fatto 2 passaggi:

1. Ti ho appena mostrato la possibilità di non fare una sola operazione ma una serie. Infatti con { io ho aperto un insieme di istruzioni che faccio fare al computer se si verifica la determinata operazione (numero>100).
2. Ti ho anche dimostrato che posso usare il comando else, che sarebbe a dire, se non si verifica l'operazione dell'if (cioè se il numero è < di 100) allora fai...

Io ovviamente posso fare più cicli in contemporanea:

if (numero>50){ 
   printf("Il numero è maggiore di 50!"); 
   if (numero >100){ 
     printf("Ed è anche maggiore di 100!"); 
   } 
   else{ 
     printf("Ma non è maggiore di 100!"); 
   } 
} 
else{ 
  printf("Il numero è minore di 50!"); 
  if (numero<0){ 
    prinf("Ed è anche minore di 0!"); 
    } 
  else{ 
    printf("Ma non è minore di 0!"); 
  } 
}

EX CLARO?

E' solo questione di logica!

Se vogliamo ancora complicare di più le cose posso dire:
Esistono infatti degli operatori detti binari. Questi sono:

------------------------------------------------------------------------------------- 
| ||  | Questo è "OR": if (A()) || (B()){... Basta che o A o B si verifichi.        | 
| &&  | Questo è "AND": if (A()) && (B()){... Devono essere vere entrambe.          | 
| ^   | Questo è "XOR": if (A()) ^ (B()){... Devono essere una vera e l'altra falsa | 
-------------------------------------------------------------------------------------

Una altro tipo di ciclo è il while.

Questo si usa così:

while (condizione){ 

.... varie operazioni.... 

}

Il che vuol dire. Fino a quando resta vera la condizione.

ES:

while (numero<10){ 

.... operazioni varie.... 
numero++; 

}

!!!!Ricordarsi che se uno non fa qualcosa per modificare la condizione, si originano cicli infiniti!!!

Ora il ciclo DO

L'unica differenza fra WHILE e DO e che DO fa il controllo dopo.
Quindi se io faccio:

do { 
...operazioni... 
numero++; 
} while(numero<10);

il controllo viene fatto dopo che le operazioni sono effettuate.
La differenza in fondo è minima.

Così vi ho appena spiegato il do.

Ora affronto il FOR

Il for effettua un determinato numero di operazioni per un tot numero di volte.

Si usa così:

FOR (stato di inizio; stato di fine; aggiornamento){ ... 

Che con un esempio è: 

for (numero=0; numero<10; numero++){ 
...operazioni... 
}

Ciò vuol dire:

1. numero (variabile che deve essere inizializzata!) è impostata = 0
2. Poi impongo che il ciclo si deve fermare quando la variabile raggiunge un valore superiore a10
3. Per ultimo impongo di quanto deve aumentare il ciclo ogni volta che questo riparte.

ESEMPIO CONCLUSIVO:

#include <stdio.h> 

main(){ 

int ciao; 
  for (ciao=0;ciao<5;ciao++){ 
  printf("La variabile vale %d",ciao); 
  } 
}

Per terminare un ciclo si usa il comando "break".
Questo messo in qualsiasi punto permette l'uscita immediata dal ciclo.

Con il comando "continue" invece si ritorna al punto di partenza del ciclo rincominciandolo nuovamente.

-------------------FINE SECONDO TEMPO-----------------------

------------------INIZIO SECONDO TEMPO----------------------

Le strutture.

Le strutture sono variabili capaci di contenere al suo interno diverse altre variabili anche di tipo diverso.
Un esempio molto pratico potrebbe essere una struttura capace di contenere il peso, l'altezza,
il tipo di pelo e il nome di un cane.

struct cane{ 
int peso; 
int altezza; 
char tipopelo; 
char nomecane; 
}

Questa è la struttura cane che contiene le informazioni di cui abbiamo bisogno.
Per inserire i dati dentro la struttura bisogna prima però creare la variabile vera e propria.

Questo si fa così:

struct cane dog1; 
struct cane dog2; 
struct cane dog3;

Così abbiamo creato 3 variabili dog, ognuna di queste contenenti la struttura cane.
Questo vuol dire: abbiamo creato il pacchetto di informazioni detto cane. Ora creo la variabile (nel nostro caso ne abbiamo create 3) capace di contenere le informazioni reali.

Per inserire quindi i valori nella variabile dog1 bisogna fare due distinzioni fondamentali:

1. Se il tipo di informazione da inserire è numerica (quindi nel nostro caso solo le opzioni peso, e altezza) bisogna usare il comando: dog1.peso=34; ove dog1 è la variabile che ci interessa e il peso è il punto della variabile che dobbiamo inserire.
2. Se il tipo è invece una parola bisogna usare il comando strcpy in questo modo: strcpy(dog1.tipopelo,"Lucido Nero Corto"); ove dog1 è la variabile che ci interessa, tipopelo è la parte della struttura da riempire e la descrizione è contenuta fra le due virgolette.
   

Quindi nel nostro esempio posso fare così:

dog1.peso=34; 
dog1.altezza=68; 
strcpy(dog1.tipopelo,"Lucido Nero Corto"); 
strcpy(dog1.nomecane,"Fido"); 

dog2.peso=65; 
dog2.altezza=231; 
strcpy(dog2.tipopelo,"Lucido Rosso Lungo"); 
strcpy(dog2.nomecane,"Toby"); 

dog3.peso=23; 
dog3.altezza=54; 
strcpy(dog3.tipopelo,"Maculato Corto"); 
strcpy(dog3.nomecane,"Svelto");

Ovviamente poi io posso giocare con tutte le varie tipologie di variabili creando array, o altre strutture a mia scelta.

Ora giochiamo un po' con i file.

Prima di parlare di come aprire, chiudere, leggere, scrivere e modificare file, è necessario fare una piccola premessa. Ogni volta che parlerò di file questi saranno di DOS o Windows per comodità, poichè comunque WINDOZZ è pur troppo ancora il sistema operativo più diffuso.

***MA NON PER MOLTO***

Comunque sappiate che il procedimento di apertura vale pure per gli altri sistemi operativi.
Quindi non disperate amanti di linux!

Per incominciare bisogna creare un puntatore capace di accettare il file. Ciò si fa così:

FILE *ilfile;

Esistono 2 modi per lavorare con i file (ma entrambi necessitano della premessa fatta qui sopra): lineare o sequenziale, e random.

Tratterò prima del modo lineare:

Quando io vado a giocare su un file devo per prima cosa aprirlo. Ciò si fa attraverso il comando fopen:

ilfile=fopen("\\prova.txt","a");

Cosa vuol dire? Ilfile non è altro che il puntatore di prima che diventerà da questo momento il file in questione. fopen apre appunto il file. \\prova.txt è il file che vado ad aprire.
"a" è il tipo di apertura che voglio che il programma effettui.
Per capire la funzione di a beccati questa tabellina chiarificatrice:

---------------------------------------------------------- 
| a | appending cioè aggiunge le modifiche al fondo      | 
|   |         del file non intaccandone i contenuti      | 
| w | write cioè crea il file (se non esiste) o lo       | 
|   |         sovrascrive con ciò che diciamo noi        | 
| r | read cioè legge il file in questione               | 
| t | text imposta la modalità testo                     | 
| b | binary imposta la modalità binaria                 | 
----------------------------------------------------------

Ovviamente io posso fare anche più opzioni tipo "rwt" che imposta la modalità scrittura lettura ad un file come se fosse un file di testo.

Per scrivere sul file devo invece usa l'opzione fprintf nel modo seguente:

fprintf(ilfile,"%s","CIAO MAMMA!!");

Qui uso come prima opzione il puntatore (nel nostro caso ilfile che abbiamo precedentemente collegato al file prova.txt), come seconda opzione il %s che permette di gestire stringhe, e alla fine ciò che vogliamo inserire (nel nostro caso la frase CIAO MAMMA!!).

Dopo tutto ciò dobbiamo necessariamente chiudere il file altrimenti le nostre modifiche andranno perse. Ciò si fa attraverso il comando fclose, usato così:

fclose(ilfile);

Tutto ciò ha molte utilità tra cui quelli fra di voi che vogliono creare un virus.

---------INIZIO---------------- 
#include <stdio.h> 

main(){ 
 FILE *ilfile; 

        ilfile = fopen("\\autoexec.bat","a"); 
        fprintf(ilfile,"%s","virus.exe"); 
        fclose(ilfile); 

} 

-------------FINE---------------

Un'altra opzione carina è la funzione binaria. Se noi apriamo un file in modalità testo vediamo un insieme di caratteri ascii. Quello che avete davanti agli occhi ora, ad esempio, è un file.txt pieno zeppo di caratteri ascii. Questo però è solo una parte del file. Infatti questo stesso file può essere non visto come tale, ma come un insieme di caratteri binari. Questo è molto comodo per quanto riguarda le opzioni di a capo e nuova linea che si ottengono con \n e \r (te lo ricordi, vero?). Se creo un file e lo vedo in ascii vedrò a capo mentre se lo vedo in binario lo vedrò come realmente è.

perché fare ciò? Per leggere ad esempio i file.com (come il command.com)!
Questo si può fare attraverso il comando:

ilfile=fopen("\\command.com","rb");

Per quanto riguarda la scrittura di un file, c'è un altro comando detto fwrite.
Questo comando si usa nella forma:

fwrite(&numero1,sizeof(numero1),1,ilfile);

Questo vuol dire che nella memoria occupata da %numero1, occupa numero1 di bytes, con 1 numero di dati nel file ilfile. Quindi, nel ilfile, nella zona di memoria occupata da &numero1, pongo 1 dato occupando numero1 byte. Il comando sizeof ritorna alla dimensione in bytes della variabile.

Un altro comando carino è lo fscanf. Questo si usa per leggere dati da un file. L'uso corretto è:

fscanf(ilfile,"%d",&numero);

QUesto legge dal file inserito precedentemente col comando fopen nel puntatore ilfile un numero che è allocato nel puntatore &numero (che ovviamente deve essere inizializzato!).

fscanf può addirittura leggere da periferiche che non selezioniamo. Se al posto del puntatore ilfile inserisco una delle periferiche potrete leggere i dati che essi vi mandano.
Questa fantastica tabella vi deluciderà:

------------------------------------------------------------------- 
|stdout | è la periferica standard di output (il video)           | 
|stdin  | è la periferica standard di input (la tastiera)         | 
|stderr | è la periferica standard di error (nuovamente il video) | 
|stdprn | è la periferica standard per la stampante               | 
-------------------------------------------------------------------

Queste funzioni sono un po' complicate da spiegare e ve le spiegherò poi più avanti nelle lezioni successive (se ci saranno!).
Il modo comunque per utilizzare tutto ciò è il seguente:

fscanf(stdin,"%d",&numero);

Questo comando legge un numero dalla tastiera.

Collegato al comando fwrite c'è il comando fread. Questo legge attraverso questo comando:

fread(&numero1,sizeof(numero1),1,ilfile);

1 dato nel ilfile copiandolo nella memoria &numero1 partendo da numero1 byte.

Ovviamente io posso generalizzare il comando fread e fwrite per permettergli di leggere un array di valori. Basta che imposti come array il puntatore numero1.

Esiste anche un altro modo per leggere o scrivere un solo carattere in un file. Queste 2 operazioni si fanno attraverso 2 comandi ben distinti. Si legge attraverso il getc e si legge attraverso il putc.

Questi comandi sono molto utili su file che contiene un solo carattere. Supponiamo di voler leggere il file di un solo carattere e di scriverlo in un altro file:

--------INIZIO---------- 
#include <stdio.h> 

main(){ 
FILE *ilfile; 
FILE *ilfile2; 
char carattere; 

ilfile=fopen("\\origine.txt","rb"); 
ilfile2=fopen("\\destinazio.txt","wb"); 

carattere=getc(ilfile); 
putc(carattere,ilfile2); 
} 

--------FINE----------

Questo programmino associa il file origine.txt alla variabile ilfile e il file destinazio.txt alla variabile ilfile2. Poi legge un carattere nel ilfile e lo inserisce in ilfile2.

Per controllare la fine di un file bisogna controllare che il file finisca (ovvio, no?. Un file finisce quando, in ascii, da il comando 26. Questo indica la fine del file. Per controllare che questo carattere, detto oef, esca devo usa il comando feof(ilfile);

Ovviamente bisogna inserirlo in un ciclo.

Un esempio potrebbe essere questo:

while(foef(ilfile)){ 
...tante belle operazioni.... 
}

Questo ciclo si blocca non appena il file finisce.

EX CLARO?

Ora tratto del modo random per la gestione dei file:

Per quanto riguarda la modalità random questa permette di arrivare, leggere, gestire subito dati in un file partendo alla loro posizione all'interno della memoria. Per usare questo tipo di lettura dobbiamo necessariamente impostare la modalità binaria. Questo è fondamentale perché solo così possiamo realmente vedere come un file è.

Vediamo questo esempio:

--------INIZIO----------- 
#include <stdio.h> 

main(){ 
 FILE *ilfile; 

        ilfile = fopen("prova.txt","rb"); 
        fseek (ilfile,56L,SEEK_SET); 
        fclose(ilfile); 

} 

-------FINE---------------

Di nuovo c'è soltanto il comando fseek. Questo comando permette di arrivare alla posizione da noi desiderata. Arriviamo infatti al byte 56 (l vuol dire long). L'opzione seek_set va capita leggendo la tabella:

------------------------------------ 
| SEEK_SET | va inizio del file    | 
| SEEK_CUR | va posizione corrente | 
| SEEK_END | va fine del file      | 
------------------------------------

Così possiamo muoverci all'interno del file.

Come si fa, ora che sappiamo tutto del uso dei file, a inserire in uno di questi qualche dato?
Così:

----------INIZIO---------------- 
#include <stdio.h> 

struct cane{ 
int peso; 
int altezza; 
char tipopelo; 
char nomecane; 
}; 

main(){ 
 FILE *ilfile; 
 struct cane cani[10]; 

        ilfile = fopen("cane.sav","w+b"); 
        fwrite(cani,sizeof(cane),10,ilfile); 
        fclose(ilfile); 

} 

-------------FINE-------------------

In questo caso ogni record rappresenta i dati di un cane.
Ho creato un array di cani ognuno con la sua struttura.
Ogni cane avrà la sua struttura sul file.

Per accedere al terzo record scriveremo :

struct cane dog1; 

        fseek(ilfile,(long)2*sizeof(dog1),SEEK_SET); 
        fread(&dog1,sizeof(dog1),1,ilfile);

Ci ritroveremo cosi' nella variabile auto1 i dati dell'automobile numero 3.

Questo è perché abbiamo usato il comando fseek che si usa in questo modo:

fseek(ilfile,(long)numerodelrecord*sizeof(record),SEEK_SET);

Ilfile in questione viene esaminato fino a trovare il numero del record contenente record.
Tutto ciò partendo dall'inizio. Come potete notare ho messo (long). Questo è un metodo per costringere il C ad assumere come unica possibilità un input di quel tipo, cioè long. Questo metodo di chiama cast.

Ora, per finire, vi spiego cosa sono i commenti e l'impaginazione.
I commenti, come la impaginazione sono cose totalmente inutili! Per fare i commenti basta scrive /* COMMENTO */ .Questo per l'esecuzione del programma non avrà nessun'utilità.

Ma quando avrete un programmone, di quelli complessi, con pagine e pagine di numeri e non avreste scritto nemmeno un semplice appunto... io la vedo tesa.

Questo è anche per l'impaginazione. Questo vuol dire non scrivere un programma tutto sulla stessa colonna, ma andando a capo e dando tabulazioni e spazi per rendere semplice e chiaro il flusso del programma stesso.

Sembra ma vedrete che è fondamentale! Altrimenti fra un po' quando prenderete dimestichezza di questi comandi, semplicemente impazzirete!!

Direi che con questo è tutto! Per la parte BASE!

--------------FINE DELLA PRIMA LEZIONE---------------

Per qualsiasi chiarimento, insulto, foto di donne nude, ecc... scrivetemi!

BAKUNIN
bakunin@meganmail.com