Laboratorio di informatica applicata
Roberto Sassi

Universita' degli studi di Milano - Dipartimento di tecnologie dell'informazione

Lez1e2 .:. Lez3e4 .:. Lez5e6 .:. Lez7e8 .:. Lez9e10 .:. Lez11e12 .:. Lez13e14 .:. Lez15e16 .:. Lez17e18 .:. Lez19e20 .:. Contact.:. Indice

Vettori e puntatori. Funzioni

Lunedì, 8 Marzo 2004

Vettori, stringhe e blocchi di memoria

• Array

  Un vettore e' un insieme contiguo di elementi dello stesso tipo (cioe' che vengono allocati in memoria in un blocco unico).

  	    int x[100];
  		

  Definisce un array x costituito da 100 numeri interi. Che spazio occupa nella memoria? Lo spazio occupato da 100 numeri interi (400byte). x e' l'etichetta della prima cella di memoria.

• Indici

  E' possibile referenziare uno specifico elemento del vettore utilizzando un indice.
  ATTENZIONE: il C numera gli elementi di un array a partire da 0,
  • il primo elemento lo assegno con x[0]=1;
  • ... mentre l'ultimo con x[99]=100;
  Ad esempio, assegnamo al vettore x, i numeri da 1 a 100

  		...
  		for(i=0; i<100; i++) x[i]=i+1;
  		...
  		

• Stringhe

  Una stringa e' un array di caratteri che finisce con un terminatore di stringa: '\0' (una cella tutta a zero). ATTENZIONE: NON dimenticare il terminatore!
  Ad esempio assegnamo alla stringa s il valore "Crema"

  	    char s[6];
  	    s[0]='C';
  	    s[1]='r';
  	    s[2]='e';
  	    s[3]='m';
  	    s[4]='a';
  	    s[5]='\0';
  		

  Nota che la stringa s e' composta da 6 caratteri. Il terminatore di stringa e' un carattere come gli altri! Il simbolo '\0' assomiglia a quello che usiamo per andare a capo '\n'.

• Costanti stringa

  Se dobbiamo assegnare stringhe piu' lunghe, il metodo che abbiamo appena utilizzato diventa poco pratico. Pensa alla stringa Laboratorio di Informatica applicata. Inoltre potresti sbagliarti a contare i caratteri! Un alternativa pratica e':

  	    char s[]="Laboratorio di Informatica applicata";
  		

  E' un esempio di array non dimensionato a cui si assegna una costante stringa.
  In C una costante stringa si racchiude tra virgolette doppie, come "Crema". Il terminatore di stringa viene aggiunto automaticamente dal compilatore.
  

  ATTENZIONE: La costante stringa "M" è diversa dal carattere 'M' ! "M" e' composta da due caratteri: ''M'+'\0'

  
  La dimensione dell'array non dimensionato viene stabilita dal compilatore che conta il numero di caratteri di cui è composta la costante stringa (+1), alloca la memoria e ve la copia.
  Una costante stringa che avevamo già incontrato:

  	printf("Il risultato di i=x+3 e' %d" , i);
  

• Usa le funzioni di libreria!

  Lo standard ANSI prevede una libreria standard che contiene gia' molte funzioni per manipolare le stringhe. Ad esempio, per copiare una stringa in un altra usa strcpy().

  #include <stdio.h>
  main()
  {
      char s[128];
  
      // strcpy(s_to,s_from) copia la stringa s_from in s_to
      // fino a quando trova un terminatore di stringa
      strcpy(s,"Laboratorio di Informatica applicata");
      printf("%s",s);
  }
  

  Non fare lavoro inutile: se c'e' una funzione gia' pronta usala!

  Struttura della memoria e allocazione

  • Mappa della memoria

    La conformazione di un programma è concettualmente rappresentata in figura. Quando eseguiamo un programma il sistema operativo gli dedica una parte della memoria disponibile. Questo blocco è diviso in quattro parti:
    • Il segmento di codice (il programma vero e proprio)
    • Il segmento dati (tutte le variabili che sono fuori da ogni funzione)
    • Lo stack dati (la pila, serve ad es. per il passaggio dei parametri alle funzioni)
    • Lo heap (una zona di memoria "libera" che può essere richiesta dal programma tramite le funzioni di allocazione dinamica).
    Ciascuna di queste quattro parti è costituita da un certo numero di celle elementari di 8 bit ciascuna (1 byte) che viene identificata tramite un indirizzo.

  • Puntatori

    Ci sono variabili che contengono numeri interi, caratteri o numeri reali. Un puntatore è una variabile che contiene l'indirizzo di una altra variabile. Operazioni elementari:
    • L'operatore & data un variabile "estrae" l'indirizzo
    • ... mentre * dato un indirizzo "fornisce" il contenuto della variabile a quel indirizzo.

  • Equivalenza tra vettori e puntatori

    Se

    int *p;
    int i, a[10];
    
    p = &a[0];
    

    allora vale la relazione

    *(p + i) == a[i]
    

    Primo esercizio puntatori

    main()
    {
        int n;
        int *p;
        int x[100];
    
        p=x;
        p[0]=3;
    
        // assegno un valore alla variabile n
        n=5;
        printf("Il valore della variabile n e' %d\n", n);
        printf("L'indirizzo della variabile n e' %d\n\n", &n);
    
        // assegno un valore al primo elemento dell'array x[]
        x[0]=5;
        printf("Il primo elemento dell'array x e' %d\n", x[0]);
    
        // assegno a p il valore dell'etichetta x
        p=x;
    
        // posso accedere al vettore x tramite il puntatore p
        printf("p[0] vale %d", p[0]);
        printf(" e p vale %d\n\n", p);
    
        // MA NON POSSO FARE IL VICEVERSA !!!!
        // x è solo una etichetta NON un puntatore !!!!
        // verifica: SE COMPILO HO ERRORE
        //    x=p;
        //    printf("x[0] vale %d\n\n", x[0]);
    
        // Infatti un puntatore è una variabile QUINDI occupa spazio in memoria.
        // x è una etichetta e NON occupa spazio in memoria. x[], che è
        // una variabile, occupa spazio in memoria
        // ATTENZIONE:
        // variabile -> occupa celle di memoria
        // puntatore -> occupa celle di memoria
        // etichetta -> NON occupa celle di memoria (serve solo al compilatore)
        // QUINDI:
        // variabile -> ha un indirizzo
        // puntatore -> ha un indirizzo
        // etichetta -> NON ha un indirizzo: E' UN INDIRIZZO !!!!!!
        // verifica:
        printf("L'indirizzo di x[0] e' %d\n", &(x[0]));
        printf("L'indirizzo di x e' %d\n", &x);  // INTERPRETATO DAL COMPILATORE
                                                 // COME &(x[0])
        printf("L'indirizzo di p e' %d\n", &p);
    
    }
    

    

    Esercizio Array in memoria

    Che indirizzo hanno le celle di un array?
    

    main()
    {
        int i, x[100];
    
        for(i=0; i<100; i++) x[i]=i+1;
    
        printf("Il valore di x e' %d\n", x);
        printf("Il valore di x[0] e' %d\n", x[0]);
        printf("L'indirizzo di x[0] e' %d\n", &x[0]);
        printf("Il valore di x[99] e' %d\n", x[99]);
        printf("L'indirizzo di x[99] e' %d\n", &x[99]);
        printf("La memoria occupata dal vettore e' %d\n",
            (void *)&x[99]+sizeof(int)-(void *)&x[0]);
    }
    

    

    Secondo esercizio puntatori

    Come mai la somma non sembra funzionare con i puntatori?
    Come mai gli indirizzi p1 e p2 sono così diversi?

    #include <stdio.h>
    int i=2; // Questa è una variabile globale. Viene messa dal compilatore
             // nel segmento dati
    main()
    {
        double d=2.0;
        int * p1;
        double * p2;
    
        p1=&i;
        p2=&d;
    
        printf("\n");
        printf("*p1 vale %d\n",*p1);
        printf("p1 vale %d\n",p1);
        printf(" ... mentre p1+1: %d\n\n",p1+1);
    
        printf("*p2 vale %f\n",*p2);
        printf("p2 vale %d\n",p2);
        printf(" ... mentre p2+1: %d\n\n",p2+1);
    }
    

    

  • L'aritmetica tra puntatori può servire per accedere agli elementi di un array.
    Ad esempio: data la stringa char s[20];

            s[3]='c';
    		

    e

            *(s+3)='c';
    		

    sono equivalenti. Scegliamo il primo modo!

  Funzioni e ricorsione

  • Fattoriale

    /*
     *  fattoriale
     */
    #include <stdio.h>
    #include <stdlib.h>
    void main()
    {
        int n, fatt;     // con delle virgole si dichiarano tante variabili int
        int i;    // indice del ciclo
    
        /* input dell'intero */
        printf("intero---->");
        scanf("%d", &n);
    
        /* calcolo del fattoriale */
        fatt=1;   /* provate a togliere questa riga e vedete cosa succede!!! */
        for (i=1; i<=n; i++)
        {
            fatt = fatt * i;
        }
    
        /* visualizzazione risultato */
        printf("\n Il fattoriale di %d e' l'intero %d\n",n,fatt);
    }
    

  • Fattoriale funzionale

    Il calcolo del fattoriale può essere racchiuso in una funzione

    /*
     *  fattoriale con funzione
     */
    #include <stdio.h>
    int calcola_fattoriale(int n);
    
    void main()
    {
        int n, fatt;     // con delle virgole si dichiarano tante variabili int
    
        /* input dell'intero */
        printf("intero---->");
        scanf("%d", &n);
    
        /* calcolo del fattoriale */
        fatt=calcola_fattoriale(n);
    
        /* visualizzazione risultata */
        printf("\n Il fattoriale di %d e' l'intero %d\n",n,fatt);
    }
    
    int calcola_fattoriale(int n)
    // Il calcola del fattoriale è racchiuso in questa funzione
    {
        int i, fatt=1;
        for (i=1; i<=n; i++)
        {
            fatt = fatt * i;
        }
        return(fatt); // ritorna il valore calcolato
    }
    

    In C le variabili sono passate sempre per VALORE. Se vogliamo costruire una procedura (cioè una funzione che non ritorna nessun valore ma che modifica uno dei suoi parametri), dobbiamo fornire alla funzione il VALORE dell'indirizzo della variabile.

    /*
     *  fattoriale con procedura
     */
    #include <stdio.h>
    void calcola_fattoriale(int n, int *fatt);
    
    void main()
    {
        int n, fatt;     // con delle virgole si dichiarano tante variabili int
    
        /* input dell'intero */
        printf("intero---->");
        scanf("%d", &n);
    
        /* calcolo del fattoriale */
        calcola_fattoriale(n, &fatt);
    
        /* visualizzazione risultata */
        printf("\n Il fattoriale di %d e' l'intero %d\n",n,fatt);
    }
    
    void calcola_fattoriale(int n, int *fatt)
    // Il fattoriale è calcolato con una procedura: nota che il
    // tipo di dato che restituisce è void
    // Inoltre nota che int è stato specificato due volte.
    // Non è possibile usare (int n, *fatt)
    {
        int i;
        *fatt=1;
        for (i=1; i<=n; i++)
        {
            *fatt = *fatt * i;
        }
        // non c'è il return
    }
    

  • Ricorsione

    La ricorsione (o definizione circolare) è il processo di definizione di una operazione (od oggetto) in termini di se stesso. Vediamo come costruire una funzione calcola_fattoriale() ricorsiva:

    /*
     *  fattoriale con ricorsione
     */
    #include <stdio.h>
    int calcola_fattoriale(int n);
    
    void main()
    {
        int n, fatt;     // con delle virgole si dichiarano tante variabili int
    
        /* input dell'intero */
        printf("intero---->");
        scanf("%d", &n);
    
        /* calcolo del fattoriale */
        fatt=calcola_fattoriale(n);
    
        /* visualizzazione risultata */
        printf("\n Il fattoriale di %d e' l'intero %d\n",n,fatt);
    }
    
    int calcola_fattoriale(int n)
    // La funzione è ricorsiva, cioè chiama se stessa
    {
        int risultato;
    
        if(n==1) risultato=1;
        else risultato=n*calcola_fattoriale(n-1);
        return(risultato);
    }
    

  Lab

  Esercizio 1

  Usando DevC++, scrivi un breve programma che inizializza una stringa s al valore esercitazione e la stampa.
  Sostituisci al terminatore di stringa uno spazio ' '. Cosa succede?
  Il programma termina? Se si interrompe, perché accade?

  Esercizio 2

  Incolla in un file il testo del programma che calcola il fattoriale di un numero intero. Compilalo e prova ad eseguirlo.
  Aggiungi un ciclo che permetta all'utente di calcolare più di un risultato, senza dover eseguire nuovamente il programma. (Suggerimento: chiedi all'utente se vuole continuare o no).
  Perchè con numeri interi grandi vengono fuori valori strani?
  Cosa succede se fatt è un long?

  Esercizio 3

  Svolgi l'esercizio descritto nel file CarattereCompito.c.
  Aggiungi un puntatore per ogni tipo di dato e metti in ciascuno l'indirizzo della variabile corrispondente. Quindi usa printf per vedere il valore dei puntatori.
  Cosa succede se stampi la somma di due puntatori?

  Esercizio 4

  Il programma massimoCompito.c calcola il massimo di un insieme di valori fornito dall'utente. Studialo e quindi individua l'errore.
  Rivedi l'esercizio Media.c, che era uno dei compiti per casa della scorsa lezione. Completa ora il programma massimoMediaminimoCompito.c.

  Esercizio 5: FACOLTATIVO

  Completa i due programmi critta1compito.c e decritta1compito.c.

  
  
  
  
  Informazioni sul sito

©2003 Roberto Sassi