Tipi fondamentali e tipi derivati

• Tipi fondamentali (anche detti tipi base o elementari o aritmetici), esempio:
  • char
  • int
  • float
  • double
  • enum

• Tipi derivati, esempio:
  • void
  • array
  • funzioni
  • puntatori
  • strutture
  • unioni

• array di caratteri (stringhe)
• funzioni da numeri in virgola mobile a interi
• puntatori a interi

• array di stringhe
• funzioni da puntatori di interi a interi
• puntatori a puntatori di numeri in virgola mobile

In generale, se i tipi fondamentali rappresentano i valori elementari immediatamente gestibili dal calcolatore, i tipi derivati possono essere usati per modellare domini complessi a piacere e vicini alle strutture logiche necessarie a modellare direttamente molti aspetti e problematiche del mondo che ci circonda.

Partendo dai tipi fondamentali, abbiamo percorso molti passi di astrazione verso tipi più complessi (array, funzioni, puntatori). La durata del corso ci lascia solo lo spazio per imparare a conoscere ed usare anche le strutture, un tipo derivato fondamentale per coloro che volessero proseguire lo studio del C e la programmazione di strutture dati di uso comune come liste concatenate ed alberi.

Le strutture

Spesso accade di dover integrare elementi di tipi diversi (di cui alcuni possono essere fondamentali ed altri derivati), oppure di creare delle corrispondenze non ovvie tra indice ed interpretazione dell'elemento.

Ad esempio, se volessimo rappresentare un punto sul piano cartesiano avremmo bisogno di due valori in virgola mobile che ne rappresentino l'ascissa e l'ordinata. A questo scopo potremmo usare un vettore con due posizioni:

  double punto[2];

dove punto[0] rappresenta l'ascissa e punto[1] l'ordinata. Ma se volessimo rappresentare due punti usando una matrice

  double punti[2][2];

otterremmo una notazione ambigua di difficile interpretazione.

Le strutture permettono di aggregare dati eterogenei usando nomi invece che indici per accedere ai vari elementi.

Nell'esempio, potremmo definire il tipo struttura Punto come:

  struct Punto {
    double ascissa;
    double ordinata;
  };

e poi dichiarare le due variabili come elementi di un vettore di punti:

  struct Punto punti[2];

Notare le seguenti convenzioni sintattiche:

• Quando riferiamo un tipo struttura dobbiamo sempre usare la parola chiave struct (anche quando dichiariamo un array)
• La definizione del tipo struttura deve essere chiusa da un punto e virgola dopo la parantesi graffa
• I nomi elencati all'interno della struttura vengono detti membri oppure campi
• Per accedere ai valori dei campi di una struttura si usa la dot notation punti[0].ascissa

  typedef struct {
    double ascissa;
    double ordinata;
  } Punto;

Adesso Punto può essere impiegato senza premettere struct.

Per concludere questo esempio, ecco un programma completo che definisce il tipo struttura Punto, crea due punti e ne calcola la distanza sfruttando una funzione opportuna.

/* programma che, dati due punti sul piano cartesiano,
ne calcola la distanza */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct  {
  double ascissa;
  double ordinata;
} Punto;

double distanza(Punto, Punto);

int main(int argc, char *argv[]) {

  Punto punti[2];

  punti[0].ascissa = 5;
  punti[0].ordinata = 7;

  punti[1].ascissa = 2;
  punti[1].ordinata = 4;

  printf("%f\n",distanza(punti[0],punti[1]));

  return EXIT_SUCCESS;
}

double distanza(Punto p1, Punto p2) {

  double delta1 = p1.ascissa  - p2.ascissa;
  double delta2 = p1.ordinata - p2.ordinata;

  return sqrt((delta1*delta1)+(delta2*delta2));

}

È possibile anche:

• Definire funzioni che restituiscono valori di un qualsiasi tipo struttura definito dall'utente
• Effettuare assegnamenti tra variabili dello stesso tipo struttura senza riferirne i singoli membri, esempio:

    punti[0] = punti[1];
  
  

  copia i valori dei campi ascissa e ordinata di punti[1] nei corrispondenti campi di punti[0], ovvero è equivalente a:

    punti[0].ascissa = punti[1].ascissa;
    punti[0].ordinata = punti[1].ordinata;
  
  

• Definire puntatori a variabili di tipo struttura, esempio:

    Punto *p = &punti[0];
  
  

  In questo caso per accedere i campi possiamo usare le notazioni alternative riportate sotto:

    (*p).ascissa = 10; // sconsigliata
  
    p->ordinata = 20;  // più frequente
  
  

  malloc che, dato un intero unsigned che rappresenta la dimensione in byte dell'oggetto da allocare, restituisce un puntatore allo spazio
    allocato per l'oggetto, oppure NULL se non c'e' spazio disponibile.
    
  calloc che alloca lo spazio per un array di oggetti, ognuno della dimensione opportunamento speficato, restituendo un puntatore allo
    spazio allocato oppure NULL se non c'e' spazio disponibile.  
  
  realloc serve per riallocare lo spazio associato ad un oggetto puntato dal puntatore passato come argomento. La nuova dimensione 
    dell'oggetto puo' essere maggiore o minore a quella attuale.

    free che rende libero lo spazio corrispondente all'oggetto puntato dal puntatore passato come argomento.

Vediamo un semplice esempio di allocazione dinamica della memoria, ottenuto utilizzando le strutture in combinazione con i puntatori.

/* programma che memorizza un punto del piano
cartesiano in una struttura*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct  {
  int ascissa;
  int ordinata;
  struct Punto *next; 
} Punto;


int main() {

  Punto *NuovoPunto;
  int asc,ord;

  printf("Inserisci l'ascissa\n");
  scanf("%d",&asc);
  printf("Inserisci l'ordinata\n");
  scanf("%d",&ord);
  NuovoPunto=malloc(sizeof(Punto));
  NuovoPunto->ascissa=asc;
  NuovoPunto->ordinata=ord;
  NuovoPunto->next=NULL;
  printf("Ecco il punto che hai inserito\n");
  printf("(%d,%d)\n",NuovoPunto->ascissa,NuovoPunto->ordinata);

  printf("Adesso lo cancelliamo\n");
  free(NuovoPunto);

  printf("Memoria liberata!\n");
  
  return EXIT_SUCCESS;
}