Sistemi operativi, A.A. 2011/2012 (M. Cesati)
Scaletta esercitazione #4, 29.03.2012

1 Richiami sulle funzioni
  1.1 Effetto e risultato di una funzione
  1.2 Valore restituito da una funzione (return)
  1.3 Argomenti di una funzione
      1.3.1 Esempio:
            +-----------------------+
            | int g = 1;            |
            | int f(int n)          |
            | {                     |
            |     g += n;           |
            |     return g;         |
            | }                     |
            | [...]                 |
            | g = f(g); /* g <- 2 */|
            | g = f(g); /* g <- 4 */|
            | g = f(g); /* g <- 8 */|
            +-----------------------+
  1.4 Passaggio degli argomenti per valore
      1.4.1 Argomento == Variabile automatica inizializzata
      1.4.2 Esempio:
            +------------------------+
            | int g = 1;             |
            | int f(int n)           |
            | {                      |
            |     n *= 2;            |
            |     g += n;            |
            |     return g;          |
            | }                      |
            | [...]                  |
            | g = f(g); /* g <-  3 */|
            | g = f(g); /* g <-  9 */|
            | g = f(g); /* g <- 27 */|
            +------------------------+

2 Richiami sui puntatori
   2.1 Operatori * e &
   2.2 Uso dei puntatori negli argomenti (passaggio per riferimento)
       2.2.1 Esempio:
             +-------------------------+
             | int g = 1;              |
             | int f(int *n)           |
             | {                       |
             |     *n *= 2;            |
             |     g += *n;            |
             |     return g;           |
             | }                       |
             | [...]                   |
             | g = f(&g); /* g <-  4 */|
             | g = f(&g); /* g <- 16 */|
             | g = f(&g); /* g <- 64 */|
             +-------------------------+
   2.3 Differenze e analogie tra vettori e puntatori
       2.3.1 Vettore:
             +-------------------------------+
             |                               |
             | int v[8];                     |
             |                               |
             |    +--+--+--+--+--+--+--+--+  |
             | v: |  |  |  |  |  |  |  |  |  |
             |    +--+--+--+--+--+--+--+--+  |
             |      0  1  2  3  4  5  6  7   |
             +-------------------------------+
       2.3.2 Puntatore:
             +-------------------------------+
             | int *p;                       |
             |                               |
             |    +---+         +--+         |
             | p: | --|-------> |  |...      |
             |    +---+         +--+         |
             +-------------------------------+
   2.4 Operazioni sui puntatori
       2.4.1 Esempio:
             +----------------------------------+
             | int v[2];                        |
             | int *p;                          |
             | v[0] = v[1] = 1;                 |
             | p = &v[1];                       |
             | *p = 2; /* v == {1,2} p=&v[1] */ |
             | ++*p;   /* v == {1,3} p=&v[1] */ |
             | --*p--; /* v == {1,2} p=&v[0] */ |
             | ++*p;   /* v == {2,2} p=&v[0] */ |
             +----------------------------------+
   2.5 Somma di puntatore e costante
       2.5.1 L'aritmetica e' sugli elementi, non sugli indirizzi
   2.6 Differenza tra puntatori
       2.6.1 Esempio
             +----------------------+
             |int v[2];             |
             |int *p, *q;           |
             |p = v;   /* &v[0] */  |
             |q = v+1; /* &v[1] */  |
             |/* sizeof(int) == 4 */|
             |/* q - p == 1       */|
             +----------------------+
   2.7 Passaggio di un vettore come argomento di una funzione
        2.7.1 Equivale al pass. per valore dell'indirizzo di base

3 Richiami sulle strutture
   3.1 Accesso ai campi della struttura
       3.1.1 Operatore "."
       3.1.2 Operatore "s->f" equivalente a "(*s).f"
   3.2 Inizializzazione dei campi di una struttura
       3.2.1 Inizializzazione per ordine
       3.2.2 Inizializzazione per nome
       3.2.3 Esempio
             +---------------------------------+
             |struct prova {                   |
             |    int primo;                   |
             |    int secondo;                 |
             |    int terzo;                   |
             |};                               |
             |struct prova p1 = { 1, 2, 3 };   |
             |struct prova p2 = {              |
             |    .primo = 1,                  |
             |    .secondo = 2,                |
             |    .terzo = 3                   |
             |};                               |
             +---------------------------------+
   3.3 Passaggio di una struttura ad una funzione
       3.3.1 Esempio
             +--------------------------------------------+
             |#include <stdio.h>                          |
             |#include <stdlib.h>                         |
             |                                            |
             |struct prova {                              |
             |    int secondo;                            |
             |    int primo;                              |
             |    int terzo;                              |
             |};                                          |
             |                                            |
             |struct prova p1 = { 1, 2, 3 };              |
             |                                            |
             |struct prova p2 = {                         |
             |    .primo = 1,                             |
             |    .secondo = 2,                           |
             |    .terzo = 3                              |
             |};                                          |
             |                                            |
             |void f(struct prova *pp)                    |
             |{                                           |
             |    printf("%d %d %d\n", pp->primo,         |
             |            pp->secondo, pp->terzo);        |
             |    pp->terzo++;                            |
             |}                                           |
             |                                            |
             |void g(struct prova vp)                     |
             |{                                           |
             |    printf("%d %d %d\n", vp.primo,          |
             |            vp.secondo, vp.terzo);          |
             |    vp.terzo++;                             |
             |}                                           |
             |                                            |
             |int main(void)                              |
             |{                                           |
             |    f(&p1);                                 |
             |    g(p2);                                  |
             |    printf("%d %d %d\n", p1.primo,          |
             |           p1.secondo, p1.terzo);           |
             |    printf("%d %d %d\n", p2.primo,          |
             |           p2.secondo, p2.terzo);           |
             |    return EXIT_SUCCESS;                    |
             |}                                           |
             +--------------------------------------------+

=====