Tipo → è un concetto astratto che esprime l’insieme dei valori e le operazioni permesse.

I tipi di dato possono essere:

• predefiniti (built – in);
• definiti dal programmatore

Possono essere:

• Tipi semplici, predefiniti: int, double, float, char;
• Semplici e definititi dal programmatore (enumerativi);
• Tipi di dati strutturati e definiti dal programmatore (Array e struct).

Definizione di nuovi tipi

typedef int intero;
intero numero; //Equivale a 
int numero; 

typedef → è la definizione di un sinonimo.

Definizione di tipi enumerativo

//DEFINIAMO UN NUOVO TIPO
typedef enum {gen, feb, mar, apr} tipo_mese; //gen vale 0, feb vale 1 ecc...
tipo_mese mese; 

//DICHIARIAMO LA VARIABILE
enum {gen, feb, mar, apr} mese;

Enumerazione

Normalmente, in C il valore intero 0 significa FALSO, e 1 significa VERO

typedef enum {falso, vero} boolean;

Normalmente le costanti dell’enumerazione sono rappresentate da numeri a partire da 0 in avanti, ma possiamo anche imporre le nostre condizioni

typedef enum {lun = 1, mar, mer, gio, ven, sab, dom} tipo_giorno;

I valori saranno da 1 a 7. lun vale 1, mar val 2 ecc…

Sono definite le operazionie <, ==, > ecc…

Esempio 1

typedef enum {gen, feb, mar, apr} tipo_mese;

typedef struct
{
	int giorno
	tipo_mese mese;
	int anno;
} tipo_data; //Oltre a int, double, char, ci sarà anche tipo_data

tipo_data oggi, domani, dopodomani; //sono tre variabili di tipo struct

oggi.giorno;
oggi.anno;
oggi.mese; //può essere gen, feb, mar, apr... 0 = gen, 1 = feb, 2, 3

Esempio 2

typedef struct
{
	int giorno
	tipo_mese mese;
	int anno;
} tipo_data; //Oltre a int, double, char, ci sarà anche tipo_data

typedef struct 
{
	char nome [20];
	char cognome [20];
	tipo_data nato_il;
	char nato_a[15];
	char codice_fiscale[16];
	int stipendio;
} dipendente;

dipendente persona1, persona2; //si possono dichiarare le variabili

//Aumento lo stipendio del 10%
persona1.stipendio += (persona1.stipendio*10)/100; //stipendio è l'attributo di persona 1

Esempio 3

typedef enum {disabled, enabled} Status; //disabled ha il valore 0, enabled ha il valore 1

typedef struct
{
	int numeroCanale;
	Status statoProgrammazione;
	float livelloLuinosita;
	float livelloColore;
	float LivelloVolume;
} CanaliTV;

Typedef con ARRAY

typedef char venticaratteri[20]; //un arrai di 20 char
typedef int iArray[20]; //un array di 20 int

venticaratteri nome, cognome;

Si introduce un nuovo tipo, venticaratteri, il tipo degli array di 20 elementi di tipo char. Indica che nome e cognome sono di tipo venticaratteri, cioè due array di 20 char. (da 0 a 19, l’ultimo elemento è il terminatore ‘\0’).

Matrici multidimensionali

typedef int Matrix2d [20][30];
Matrix2d A; //Variabile bidimensionale [20][30]

typedef float Matrix3d [20][30][40];
Matric3d B; //Variabile tridimensionale [20][30][40]

typedef int Vettore[20];
typedef Vettore MatriceIntera20per20[20]; //20 vettori che a sua volta ha 20 interi
typedef int Matrice20per20 [20][20]; //Equivale alla dichiarazione precedente

MatriceIntera20per20 matrice;
int matrice[20][20]; //dichiarazione abbreviata

Esercizio

Calcolo del perimetro di un poligono

#include <stdio.h>
#include <math.h> //Funzioni matematiche
#define N 5 //Pentagono

int main()
{
	int i = 0;
	float perimetro = 0;

	typedef struct
	{
		float x;
		float y;
	} punto;

	typedef punto N_agono[N];	
	N_agono pn = {{0,0}, {0.2,1}, {1,1}, {2,0.5}, {1, -3}}; //pn array di 5 elementi composto dalla struct punto (x, y)

	sizeof(N_agono);
	
	//Calcoliamo il perimetro come la distanza tra coppie di numeri consecutivi
	while ( i < N-1) 
	{
		perimetro += sqrt((pn[i].x - pol[i+1].x) * (pn[i].x - pol[i+1].x) + (pn[i].y - pol[i+1].y) * (pn[i].y - pol[i+1].y));
		i++;
	}
	perimetro += sqrt((pn[0].x - pn[N-1].x) * (pn[0].x - pn[N-1].x) + (pn[0].y - pn[N-1].y) * (pn[0].y - pn[N-1].y));
	
	return 0;
}

• sizeof(type)

  E’ un operatore che restituisce l’occupazione di memoria di un tipo.

variabile += valore → equivale a variabile = variabile + valore;

Abbiamo costruito un modello del poligono:

• Scelto quali informazioni memorizzate (le coordinate dei punti nell’ordine in cui definiscono i segmenti)
• Scelto di quali astrazioni avvalerci (un vettore di record e non due vettori separati).
• Formuliamo le operazioni definite sull’oggetto in termini della rappresentazione scelta.

Esercizio 2

Rappresentiamo insiemi di numeri interi da 0 a N-1. Gli insiemi non ammettono duplicati, consideriamo solo i primi N numeri interi.

int insieme [N];
//OPPURE
typedef int tipo_insieme[N];
tipo_insieme insieme;

Supponiamo di voler rappresentare un insieme di lettere → N = 26

Sfruttiamo l’ordinamento delle lettere per metterle in corrispondenza con gli interi nell’array: A → 0, B →1, Z → 25.

typedef int alfabeto [26];

alfabeto emptyset = {0,0,0,0,0,...,0}; //Inizializziamo gli elementi a 0
alfabeto soloa = {1,0,0,0,0,0,...,0}; //Inizializzo solo la A ad 1
alfabeto acf = {1,0,1,0,0,1,0,...,0}; //Inzializzo solo a, c ed f

Gli insiemi sono intrinsecamente ordinati vista l’associazione biunivoca tra indici ed elementi.

typedef int alfabeto[26];
alfabeto S,T,U,I; //4 variabili di tipo alfabeto, ogni variabile è un array di 26 elementi
//Tutti gli elementi saranno messi a 0, tranne il valore corrispondente alla posizione della lettera, che sarà messa a 1

//CALCOLIAMO L'UNIONE DI S e T
i=0;
while (i<N){
	U[i] = (S[i] == 1 || T[i] == 1); //l'elemento U[i] sarà 1 se o S[i] o T[i] saranno 1
	i = i+1;
}

//CALCOLIAMO in I L'INTERSEZIONE DI S e T
i=0;
while (i<N){
	I[i] = (S[i] == 1 && T[i] == 1); //L'elemento I[i] sarà uguale a 1 se S[i] e T[i] sono uguali a 1
	i = i+1;
}