Array

Estratto da:

http://programmazione.html.it/c/c_21.ht

Un array può essere definito come una "collezione organizzata di oggetti". Analizziamo la definizione e capiremo molte cose, innanzitutto il concetto di "collezione" implica che tali oggetti siano dello stesso tipo, così, prendendo spunto dal mondo reale, potremmo definire un array di mele, che, quindi non può contenere nessun "oggetto pera"; un array in C è una collezione di variabili dello stesso tipo.

"Organizzata" implica che sia possibile identificare univocamente tutti gli oggetti dell'array in modo sistematico; questo in C viene fatto tramite l'uso di indici numerici che, in un array di dimensione N, vanno da 0 ad N-1.

Riprendendo l'esempio della rubrica del cellulare, si può pensare a quando creiamo un "gruppo suonerie", ad esempio di nome "amici scuola"; tale gruppo può contenere a tutti gli effetti un certo numero di nomi/numeri dei nostri compagni di classe, ecco questo "gruppo" è un array, perchè formato da oggetti dello stesso tipo (nomi/numeri) ed indentificato da un nome (amici scuola) che li accomuna.

Ma vediamo nel dettaglio come è possibile dichiarare un array:

<pre id=code>
int myarray[10];
</pre id=code>

Come si può notare un array viene dichiarato mettendo il nome della variabile (myarray), e ,tra parentesi quadre, la cifra che identifica il numero di elementi dello stesso tipo (int) e quindi la dimensione dell'array.

Nell'esempio, ognuno dei dieci interi viene chiamato elemento dell'array e dieci è la dimensione dell'array. In C, come già detto, ogni elemento viene identificato da un numero, contando da 0 (invece che da 1) ed arrivando ad N (la dimensione, nel nostro esempio uguale a 10) - 1 (quindi arriviamo a 9).

Vediamo come è possibile dichiarare array di float o di char:

<pre id=code>
float float_array[12];
char char_array[7];
</pre id=code>

Una volta dichiarato un array è possibile assegnare il valore alla posizione corrispondente, richiamandola tramite l'indice, ad esempio se volessi inserire il valore 87.43 nell'array di float alla quinta posizione, basta scrivere:

<pre id=code>
float_array[4] = 87.43
</pre id=code>

Mentre se volessi utilizzare il valore contenuto nella terza posizione dell'array e memorizzarlo in un'altra variabile, dovrei fare:

<pre id=code>
float myvar;
myvar = float_array[2];
</pre id=code>

---

Esiste una forte relazione tra l'uso degli array e di cicli for, per il fatto che un ciclo permette di contare per un certo numero di volte. In questo modo utilizzando una variabile che incrementi (o decrementi) il suo valore ad ogni ciclo, si possono scorrere le posizioni dell'array in maniera semplice, con un notevole risparmio di codice scritto.

Per fare un esempio, assumiamo di avere un array di int di 100 elementi e di voler stampare a video il contenuto di tutte le posizioni dell'array; vista la particolare natura dell'array non inizieremo a contare da 1, ma da 0, fino ad arrivare a novantanove (quindi cento elementi effettivi). Utilizzeremo il comando di stampa sull'array con l'indice, incrementato ogni volta, preso dal ciclo for.

<pre id=code>
int int_array[100];
int i;
for (i=0; i<100; i++)
{
printf ("%d", int_array[i]);
}
</pre id=code>

In questo caso la variabile di controllo "i" del ciclo for viene usata come indice per l'array; da far notare che, a livello visivo, si capisce subito che si cicla di cento elementi, perché la condizione posta è quella di avere "i<100", iniziando a contare da zero, quindi, si esegue il ciclo fino al novantanovesimo elemento, che è minore di cento; alla successiva iterazione, prima di eseguire il corpo del ciclo, "i" viene incrementata di uno e quindi vale cento, valore che non verifica più la condizione (100 non è minore di 100, semmai è uguale) e che fa terminare il ciclo for; l'intervallo contato (da 0 a 99) è utile per rappresentare tutti e cento gli elementi dell'array, visto che, come spiegato prima, in un array si contano gli elementi partendo dallo zero.

In questo modo potrebbe essere abbastanza semplice anche inizializzare tutti i valori dell'array; supponiamo di voler dare ad ogni elemento dell'array il valore uguale alla sua posizione, con la seguente soluzione si risparmia un sacco di codice:

<pre id=code>
int int_array[100];
int i;
for (i=0; i<100; i++)
{
int_array[i] = i;
}
</pre id=code>

Naturalmente un array può essere inizializzato anche passando direttamente i valori, ad esempio, come in questo esempio:

<pre id=code>
int numeri[] { 7, 23, 4, 94, 120 };
</pre id=code>

in cui si crea un array di 5 elementi, ed è per questo che tra parentesi quadre non si mette la dimensione, in quanto ricavata dal numero di elementi compresi tra le parentesi graffe.

Prendiamo come altro esempio gli array di caratteri, che hanno una particolarità, possono essere inizializzati, senza essere divisi da virgole; ora proponiamo due forme equivalenti di inizializzazione, di cui la prima sicuramente più pratica:

<pre id=code>
char caratteri[] = "Hello World!";

char caratteri[] = { 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!' };</pre id=code>

Una particolarià cha riguarda il linguaggio C, è che non esiste un vero e proprio "tipo stringa", quello che in altri linguaggi viene chiamato "String" (si pensi al C++ o al Java). In C le stringhe vengono rappresentate tramite array di caratteri, quindi bisogna stare attenti alle operazioni che vi si compiono e ricordarsi che hanno comunque il vantaggio di godere di tutti pregi degli array, tra cui quello di poter scorrere a piacimento nella posizione della stringa stessa. Ogni array di caratteri termina con la sequenza di escape "\0" per far capire che la stringa è terminata.

Le funzioni che possono manipolare il tipo stringa possono essere utilizzate solo se si include il file string.h; a questo punto ci sono delle precisazioni da fare nell'utlizzo delle stringhe: innanzitutto una stringa viene inizializzata mettendo la frase racchiusa tra doppi apici ("a") e non tra un apice ('a') singolo.

Con il printf (ed in maniera analoga con scanf), per stampare una stringa si usa il codice %s, come mostrato nell'esempio:

<pre id=code>
#include <string.h>
#include <stdio.h>

int main()
{
char stringa[] = "Hello World!";
printf("%s \n", stringa);
}
</pre id=code>

Per sapere la lunghezza di una stringa, si usa la funzione strlen che conta, appunto, il numero di caratteri:

<pre id=code>
strlen(stringa);
</pre id=code>

mentre per copiare una stringa in un'altra si usa la funzione strcpy che ha la seguente sintassi:

<pre id=code>
strcpy(stringa_destinataria, stringa_sorgente);
</pre id=code>

Se si ricerca un carattere all'interno di una stringa, bisogna usare la strchr, come indicato di seguito;

<pre id=code>
strchr(stringa, carattere_da_cercare);
</pre id=code>

La funzione che unisce (concatena) due stringhe è la strcat illustrata qui sotto,

<pre id=code>
strcat(stringa_uno, stringa_due);
</pre id=code>

Mentre l'ultima funzione, ed anche la più importante, è la strcmp che serve per confrontare la lunghezza di due stringhe,

<pre id=code>
#include <stdio.h>
#include <string.h>

int main()
{
int temp;
int alpha[];
int beta[];
scanf ("%s \n", &alpha);
scanf ("%s \n", &beta);
temp = strcmp(alpha, beta)
printf("%d \n", temp);
}
</pre id=code>

La funzione restituisce 1 se la prima stringa è più lunga della seconda, 0 se sono lunghe uguali e -1 se la seconda è più lunga della prima.

Adesso che abbiamo visto cosa è un array, come lo si crea e come lo si inizializza, come si accede agli elementi dell'array stesso, possiamo affermare che abbiamo posto le basi per la conoscenza di uno strumento potente ed utile (permette di risparmiare decine di righe di codice) per il programmatore.

---

Ovviamente la potenza degli array risiede anche nel fatto che si possono usare degli array multidimensionali. In pratica ogni elemento contenuto da un array è a sua volta un array; in questo modo si possono rappresentare facilmente tabelle e matrici, o qualunque altra cosa che richieda un rappresentazione anche superiore, si pensi a programmi di grafica tridimensionale, dove un array cubico può essere usato per disegnare i punti all'interno dello spazio tridimensionale creato, o ad un array a quattro dimensioni, che può servire per registrare anche la variabile tempo.

Con gli array multidimensionali si possono rappresentare insomma cose che hanno più di una dimensione in maniera facile ed intuitiva. L'esempio sotto proposto usa un array bidimensionale per definire una matrice di N righe ed M colonne:

<pre id=code>
int matrix[n][m];
</pre id=code>

i cui elementi possono essere, ad esempio, stampati, utilizzando solo due cicli for, come mostrato qui sotto:

<pre id=code>
int n = 10;
int m = 12;
int matrix[n][m];
int i;
int j;

for (i=0; i<m; i++)
{
for (j=0; j<n; j++)
{
printf("%d", matrix[i][j]);
}
printf("\n");
}
</pre id=code>

---

Esempio pratico (completo):

<pre id=code>
0 /*
1 * Nome del file: rubrica.c
2 * Autore - Fabrizio Ciacchi
3 * Dicembre 2003
4 * Rubrica dimostrativa per Html.it
5 * Il programma genere un file rubrica.txt in formato CSV, Comma
6 * Separated Value, e quindi permette ad Outlook o Mozilla di
7 * importare i contatti.
8 */
9
10 // Inclusione delle librerie
11 #include <stdio.h>
12 #include <math.h>
13 #include <string.h>
14
15 // SISTEMA = 1 -> Sistema Linux;
16 // SISTEMA = 0 -> Sistema Windows;
17 #ifndef SISTEMA
18 #define SISTEMA 0
19 #endif
20
21 // Scelgo la funzione di sistema per pulire lo schermo
22 #if SISTEMA==0
23 char* pulisci = "cls";
24 #elif SISTEMA==1
25 char* pulisci = "clear";
26 #endif
27
28 // Creo la struttura per contenere i contatti
29 typedef struct
30 {
31 char nome[50];
32 char cognome[50];
33 char telefono[30];
34 char email[100];
35 char sitoweb[200];
36 } t_contatto;
37
38 // Creo la struttura per creare la lista
39 struct elemento
40 {
41 t_contatto inf;
42 struct elemento *pun;
43 };
44
45 // Prototipi delle funzioni
46 void visualizzaContatto(struct elemento* p);
47 struct elemento *aggiungiContatto(struct elemento *p);
48 struct elemento *modificaContatto(struct elemento *p);
49 struct elemento *rimuoviContatto(struct elemento *p);
50 struct elemento *leggiDaFile(struct elemento *p);
51 int salvaSuFile(struct elemento *p);
52 void substring(char *dest, char *source, int i_base, int i_dim);
53 void pausa();
54
55
56 // Funzione principale - MAIN
57
58 int main()
59 { // MAIN() - OPEN
60
61 // dichiaro la variabile scelta e la lista vuota
62 int scelta;
63 struct elemento *lista = NULL;
64
65 // Ciclo infinito
66 for ( ; ; )
67 { // FOR - OPEN
68
69 // Stampo il menu
70 system(pulisci);
71 printf (" #######################\n");
72 printf (" # RUBRICA EASY v1.0 #\n");
73 printf (" #######################\n\n");
74 printf (" 1) VISUALIZZA CONTATTO\n\n");
75 printf (" 2) AGGIUNGI CONTATTO\n\n");
76 printf (" 3) MODIFICA CONTATTO\n\n");
77 printf (" 4) RIMUOVI CONTATTO\n\n");
78 printf (" 5) LEGGI CONTATTI DA FILE\n\n");
79 printf (" 6) SALVA CONTATTI SU FILE\n\n");
80 printf (" 0) ESCI\n\n\n\n");
81 printf (" la tua scelta > ");
82
83 // Aspetto scelta dell'utente
84 scanf ("%i", &scelta);
85 scelta = (int)scelta;
86
87 if (scelta == 0) // ESCO DAL PROGRAMMA
88 { // IF - OPEN
89
90 // Stampo info di uscita
91 system(pulisci); // PULISCE LO SCHERMO
92 printf ("--------------------------------------\n");
93 printf (" http://www.HTML.i - Rubrica Easy v1.0\n");
94 printf (" Programma creato da Fabrizio Ciacchi\n");
95 printf (" http://fabrizio.ciacchi.it\n");
96 printf (" \n");
97 printf ("--------------------------------------\n\n");
98 break;
99
100 } // ELSE
101 else if (scelta == 1) // Visualizzo i contatti presenti
102 { // ELSEIF 1 - OPEN
103
104 visualizzaContatto(lista);
105
106 } // ELSEIF 1 - CLOSE
107 else if (scelta == 2) // Aggiungo un nuovo contatto
108 { // ELSEIF 2 - OPEN
109
110 lista = aggiungiContatto(lista);
111
112 } // ELSEIF 2 - CLOSE
113 else if (scelta == 3) // Modifico un contatto
114 { // ELSEIF 3 - OPEN
115
116 lista = modificaContatto(lista);
117
118 } // ELSEIF 3 - CLOSE
119 else if (scelta == 4) // Rimuovo un contatto
120 { // ELSEIF 4 - OPEN
121
122 lista = rimuoviContatto(lista);
123
124 } // ELSEIF 4 - CLOSE
125 else if (scelta == 5) // Leggo i contatti da File
126 { // ELSEIF 5 - OPEN
127
128 lista = leggiDaFile(lista);
129
130 } // ELSEIF 5 - CLOSE
131 else if (scelta == 6) // Salvo i contatti su File
132 { // ELSEIF 6 - OPEN
133
134 salvaSuFile(lista);
135
136 } // IF - CLOSE
137
138 } // FOR - CLOSE
139
140 } // MAIN() - OPEN
141
142 // Fine del MAIN, adesso ci sono le funzioni che eseguono il
143 // compito a loro assegnato
144
145 /*
146 * Visualizza i contatti presenti
147 */
148 void visualizzaContatto(struct elemento* p)
149 { // visualizzaContatto() - OPEN
150
151 if (p == NULL)
152 { // IF - OPEN
153
154 /*
155 * Se non ci sono contatti lo stampo a video
156 */
157 system(pulisci); // PULISCE LO SCHERMO
158 printf (" #######################\n");
159 printf (" # RUBRICA EASY v1.0 #\n");
160 printf (" #######################\n");
161 printf (" # VISUALIZZA CONTATTO #\n");
162 printf (" #######################\n\n");
163 printf (" Nessun contatto presente\n");
164 pausa();
165
166 } else { // ELSE
167
168 /*
169 * Stampo il primo contatto presente
170 */
171 system(pulisci); // PULISCE LO SCHERMO
172 printf (" #######################\n");
173 printf (" # RUBRICA EASY v1.0 #\n");
174 printf (" #######################\n");
175 printf (" # VISUALIZZA CONTATTO #\n");
176 printf (" #######################\n\n");
177 printf (" NOME > %s\n", p->inf.nome);
178 printf (" COGNOME > %s\n", p->inf.cognome);
179 printf (" TELEFONO > %s\n", p->inf.telefono);
180 printf (" EMAIL > %s\n", p->inf.email);
181 printf (" SITOWEB > %s\n", p->inf.sitoweb);
182 pausa();
183
184 } // IF - CLOSE
185
186 while (p != NULL)
187 { // WHILE - OPEN
188
189 /*
190 * Stampo gli altri contatti
191 */
192 system(pulisci); // PULISCE LO SCHERMO
193 printf (" #######################\n");
194 printf (" # RUBRICA EASY v1.0 #\n");
195 printf (" #######################\n");
196 printf (" # VISUALIZZA CONTATTO #\n");
197 printf (" #######################\n\n");
198 printf (" NOME > %s\n", p->inf.nome);
199 printf (" COGNOME > %s\n", p->inf.cognome);
200 printf (" TELEFONO > %s\n", p->inf.telefono);
201 printf (" EMAIL > %s\n", p->inf.email);
202 printf (" SITOWEB > %s\n", p->inf.sitoweb);
203 pausa();
204 // Leggo l'elemento successivo
205 p = p->pun;
206
207 } // WHILE - CLOSE
208
209 return;
210
211 } // visualizzaContatto() - CLOSE
212
213 /*
214 * Aggiungo un nuovo contatto
215 */
216 struct elemento *aggiungiContatto(struct elemento *p)
217 { // aggiungiContatto() - OPEN
218
219 system(pulisci); // PULISCE LO SCHERMO
220 printf (" #######################\n");
221 printf (" # RUBRICA EASY v1.0 #\n");
222 printf (" #######################\n");
223 printf (" # AGGIUNGI CONTATTO #\n");
224 printf (" #######################\n\n");
225
226 // Dichiaro le variabili
227 char nome[50];
228 char cognome[50];
229 char telefono[30];
230 char email[100];
231 char sitoweb[200];
232 t_contatto daInserire;
233 struct elemento *punt;
234
235 // Popolo la variabile daInserire
236 printf (" NOME > ");
237 scanf ("%s", nome);
238 strcpy(daInserire.nome, nome);
239 printf (" COGNOME > ");
240 scanf ("%s", cognome);
241 strcpy(daInserire.cognome, cognome);
242 printf (" TELEFONO > ");
243 scanf ("%s", telefono);
244 strcpy(daInserire.telefono, telefono);
245 printf (" EMAIL > ");
246 scanf ("%s", email);
247 strcpy(daInserire.email, email);
248 printf (" SITOWEB > ");
249 scanf ("%s", sitoweb);
250 strcpy(daInserire.sitoweb, sitoweb);
251
252 if(p != NULL)
253 { // IF - OPEN
254
255 /* creazione elementi successivi */
256 // Alloco la memoria necessaria
257 punt = (struct elemento *)malloc(sizeof(struct elemento));
258 // Metto daInserire nell'informazione del puntatore
259 punt->inf = daInserire;
260 // Metto il puntatore in testa alla lista
261 punt->pun = p;
262
263 } else { // ELSE
264
265 /* creazione primo elemento */
266 // Alloco la memoria necessaria
267 p = (struct elemento *)malloc(sizeof(struct elemento));
268 // Metto daInserire nell'informazione del puntatore
269 p->inf = daInserire;
270 // p punta a NULL, ovvero il marcatore di fine lista
271 p->pun = NULL;
272 // Assegno p a punt
273 punt = p;
274
275 } // IF - CLOSE
276
277 // Esce dalla funzione e restituisce la lista
278 return(punt);
279
280 } // aggiungiContatto() - CLOSE
281
282 /*
283 * Modifico un contatto presente
284 */
285 struct elemento *modificaContatto(struct elemento *p)
286 { // modificaContatto() - OPEN
287
288 // Dichiaro le variabili

[289 - 294 omissis]

295 struct elemento *twin = p;
296 int subscelta;
297 int i=1;
298 int n=1;
299
300 // Stampo la schermata
301 system(pulisci); // PULISCE LO SCHERMO
302 printf (" #######################\n");
303 printf (" # RUBRICA EASY v1.0 #\n");
304 printf (" #######################\n");
305 printf (" # MODIFICA CONTATTO #\n");
306 printf (" #######################\n\n");
307
308 // Stampo la lista di contatti
309 while (p != NULL)
310 { // WHILE - OPEN
311
312 printf ("%i) \t %s \t %s\n", i, p->inf.nome, p->inf.cognome);
313 // Leggo l'elemento successivo
314 p = p->pun;
315 i++;
316
317 } // WHILE - CLOSE
318
319 // Ottengo il valore originario di p
320 p = twin;
321
322 // Scelgo l'emento da modificare
323 printf("\n\n Inserisci il numero del contatto che vuoi modificare: ");
324 scanf("%i", &subscelta);
325
326 for (n=1; n<i; n++)
327 { // FOR - OPEN
328
329 /*
330 * Trovato l'elemento modifico l'informazione dentro di esso
331 */
332 if (subscelta == n)
333 { // IF - OPEN
334
335 // Popolo la variabile daInserire
336 printf (" NOME [%s] > ", p->inf.nome);
337 scanf ("%s", p->inf.nome);
338 printf (" COGNOME [%s] > ", p->inf.cognome);
339 scanf ("%s", p->inf.cognome);
340 printf (" TELEFONO [%s] > ", p->inf.telefono);
341 scanf ("%s", p->inf.telefono);
342 printf (" EMAIL [%s] > ", p->inf.email);
343 scanf ("%s", p->inf.email);
344 printf (" SITOWEB [%s] > ", p->inf.sitoweb);
345 scanf ("%s", p->inf.sitoweb);
346
347 } // IF - CLOSE
348
349 p = p->pun;
350
351 } // FOR - CLOSE
352
353 // Esce dalla funzione e restituisce la lista
354 return twin;
355
356 } // modificaContatto() - CLOSE
357
358 /*
359 * Rimuovo un contatto
360 */
361 struct elemento *rimuoviContatto(struct elemento *p)
362 { // rimuoviContatto() - OPEN
363
364 // Dichiaro le variabili
365 struct elemento *aus;
366 struct elemento *twin = p;
367 int subscelta;
368 int i=1;
369 int n=1;
370
371 // Stampo la schermata
372 system(pulisci); // PULISCE LO SCHERMO
373 printf (" #######################\n");
374 printf (" # RUBRICA EASY v1.0 #\n");
375 printf (" #######################\n");
376 printf (" # RIMUOVI CONTATTO #\n");
377 printf (" #######################\n\n");
378
379 // Stampo la lista di contatti
380 while (p != NULL)
381 { // WHILE - OPEN
382
383 printf ("%i) \t %s \t %s\n", i, p->inf.nome, p->inf.cognome);
384 p = p->pun; // scorre di un elemento
385 i++;
386
387 } // WHILE - CLOSE
388
389 // Ottengo il valore originario di p
390 p = twin;
391
392 // Scelgo l'emento da eliminare
393 printf("\n\n Inserisci il numero del contatto che vuoi rimuovere: ");
394 scanf("%i", &subscelta);
395
396 if (subscelta < i)
397 { // IF - OPEN
398
399 // Se la lista èvuota esco
400 if(p == NULL)
401 return;
402
403 // Se la lista ha almeno due elmenti...
404 if(p->pun != NULL)
405 { // IF - OPEN
406
407 // ... inizializzo un puntatore ausiliario ...
408 aus=p;
409 n++;
410
411 // ... e faccio un ciclo per trovare l'elemento da eliminare ...
412 while(n != i)
413 { // WHILE - OPEN
414
415 // Trovato l'elemento gli faccio puntare l'oggetto puntato dal suo
416 // puntatore, in poche parole "salto" l'elemento da eliminare
417 if(subscelta == n)
418 { // IF - OPEN
419
420 aus->pun=aus->pun->pun;
421
422 } else { // ELSE
423
424 // Nel caso in cui il puntatore fosse NULL, per non creare casini
425 // glielo assegniamo direttamente
426 aus=aus->pun;
427
428 } // IF - CLOSE
429
430 n++;
431
432 } // WHILE - CLOSE
433
434 } // IF - CLOSE
435
436 /*
437 * Se si vuole rimuovere il primo elemento, si assegna
438 * a p il valore del suo oggetto puntato; questo accade
439 * quando subscelta == 1
440 */
441 if(subscelta == 1)
442 { // IF - OPEN
443
444 p=p->pun;
445
446 } // IF - CLOSE
447
448 } // IF - CLOSE
449
450 // Copia di nuovo il valore p modificato in twin
451 twin = p;
452
453 // Esce dalla funzione e restituisce la lista
454 return twin;
455
456 } // rimuoviContatto() - CLOSE
457
458 /*
459 * Leggo i contatti dal file rubrica.txt
460 */
461 struct elemento *leggiDaFile(struct elemento *p)
462 { // leggiDaFile - OPEN
463
464 // Dichiaro le variabili
465 t_contatto daInserire;
466 t_contatto vuoto; // elemento vuoto
467 struct elemento *punt = p;
468 char linea[500]; // stringa per l'acquisizione
469 int index=0; // inizializza l'indice
470
471 // Apre il file
472 FILE *stream = fopen("rubrica.txt","rt");
473
474 // Salvo la lista di contatti
475 while(fgets(linea, 500, stream) != NULL)
476 { // WHILE - OPEN
477
478
479 index = strcspn(linea, ",");
480 strncpy(daInserire.nome, linea, index);
481 substring(daInserire.nome, daInserire.nome, 0, index-1);
482 substring(linea, linea, index+1, strlen(linea));
483 index = strcspn(linea, ",");
484 strncpy(daInserire.cognome, linea, index);
485 substring(daInserire.cognome, daInserire.cognome, 0, index-1);
486 substring(linea, linea, index+1, strlen(linea));
487 index = strcspn(linea, ",");
488 strncpy(daInserire.telefono, linea, index);
489 substring(daInserire.telefono, daInserire.telefono, 0, index-1);
490 substring(linea, linea, index+1, strlen(linea));
491 index = strcspn(linea, ",");
492 strncpy(daInserire.email, linea, index);
493 substring(daInserire.email, daInserire.email, 0, index-1);
494 substring(linea, linea, index+1, strlen(linea));
495 strcpy(daInserire.sitoweb, linea);
496 substring(daInserire.sitoweb, daInserire.sitoweb, 0, strlen(daInserire.sitoweb)-2);
497
498 // Aggiunge l'elemento alla lista
499 p = punt;
500 punt = (struct elemento *)malloc(sizeof(struct elemento));
501 punt->inf = daInserire;
502 punt->pun = p;
503
504 // azzera il valore di daInserire
505 daInserire = vuoto;
506
507 } // WHILE - CLOSE
508
509 // Chiude il file
510 fflush(stream);
511 fclose(stream);
512
513 // Esce dalla funzione e restituisce la lista
514 return(punt);
515
516 } // leggiDaFile - CLOSE
517
518 /*
519 * Salvo i contatti inseriti in un file di nome rubrica.txt
520 */
521 int salvaSuFile(struct elemento *p)
522 { // salvaSuFile() - OPEN
523
524 // Apre il file
525 FILE *stream = fopen("rubrica.txt","w");
526
527 // Salvo la lista di contatti
528 while (p != NULL)
529 { // WHILE - OPEN
530
531 // Scrive sul file
532 fprintf(stream, "%s,%s,%s,%s,%s\n", p->inf.nome, p->inf.cognome, p->inf.telefono, p->inf.email, p->inf.sitoweb);
533 // legge l'emento successivo
534 p = p->pun;
535
536 } // WHILE - CLOSE
537
538 // Chiude il file
539 fflush(stream);
540 fclose(stream);
541
542 // Esce dalla funzione
543 return;
544
545 } // salvaSuFile() - CLOSE
546
547 /*
548 * Funzione che prende una sottostringa partendo da un'indice
549 * base per un numero di caratteri pari a dimensione
550 */
551 void substring(char* dest, char *source, int i_base, int i_dim)
552 { // substring() - OPEN
553
554 int i = 0;
555
556 for (i=i_base; i<i_dim+1; i++)
557 { // FOR - OPEN
558
559 dest[i-i_base] = source[i];
560
561 } // FOR - CLOSE
562
563 dest[i]='\0';
564
565 return;
566
567 } // substring() - CLOSE
568
569 /*
570 * Funzione che blocca lo schermo ad aspetta che l'utente
571 * prema INVIO
572 */
573 void pausa()
574 { // pausa() - OPEN
575
576 char invio;
577 printf("\n\n - premi INVIO per continuare -\n");
578 invio = getchar();
579 return;
580
581 } // pausa() - CLOSE
</pre id=code>

Giovanni
---
http://www.y2ksw.com/vbulletin

Array

4 Risposte

Re: Array

Re: Array

Re: Array

Re: Array