Sei sulla pagina 1di 15

sorgenti organizzati

in file e
Makefile
organizzazione modulare del codice
organizzare il codice

utilizzo di file diversi, contenenti sottoprogrammi di utilit,


ri-utilizzabili anche in altre occasioni

sottoprogrammi sulla gestione e manipolazione di liste

sottoprogrammi di utilizzo comune (fattoriale, numero di


combinazioni, permutazioni, ...)
file di sottoprogrammi

file contenente i prototipi: header file (.h)

file contenente i sottoprogrammi: file sorgente (.c)

esempio:

liste.h

liste.c
utilizzo

#include <stdio.h>

#include "liste.h" specificare il percorso

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

lista_t *head = NULL;

prototipo specificato in liste.h


codice sottoprogramma in liste.c
...

head = insTesta(head, val);

...
liste.h

typedef struct _lista {

int val;

struct _lista * next;

} lista_t;

lista_t * insTesta(lista_t *, int);

lista_t * insCoda(lista_t *, int);

lista_t * insOrdinato(lista_t *, int);

lista_t * delElemento(lista_t *, int);

...
liste.c

#include "liste.h"

/** insTesta: inserts a new element at the beginning


* of the list, with value n
**/

lista_t * insTesta(lista_t * h, int n)

lista_t * nel;

if(nel = (lista_t *)malloc(sizeof(lista_t))){

nel->val = n;

nel->next = h;

h = nel;

} else

printf("insTesta: memory error for %d\n", n);

return h;

}
compilazione

sorgente codice oggetto

> gcc -Wall -c liste.c -o liste.o

necessario indicare il file .c che si vuole compilare e


tutti i file header di interesse

> gcc -Wall -c liste.c -o liste.o -I.

cerca nella directory . i file header di interesse


compilazione

sorgente codice oggetto

> gcc -Wall -c utilities.c -o utilities.o -I.

> ls

liste.c utilities.c

liste.h utilities.h

liste.o utilities.o

main.c
compilazione

sorgente codice oggetto

> gcc -Wall -c utilities.c -o utilities.o -I.

> gcc -Wall -c main.c -o main.o -I.

> ls

liste.c main.o

liste.h utilities.c

liste.o utilities.h

main.c utilities.o
compilazione

codici oggetto eseguibile

> gcc -o myprog liste.o utilities.o main.o -I. -lm

oppure: codici oggetto + main.c eseguibile

> gcc -o myprogr main.c liste.o utilities.o -I. -lm


make & Makefile

modo semplice per organizzare la compilazione

il comando di utilit make legge il file Makefile ed esegue


le operazioni di compilazione specificate

Makefile specifica quali file compilare, ordine,


dipendenze ed opzioni
Makefile - v1

nome della regola

myprog: main.c liste.c utilities.c


tutti i .c da compilare

gcc -Wall -o myprog main.c liste.c utilities.c -I. -lm

TAB

> make
se non si specifica nulla, viene eseguita la prima regola del file
nome_regola : file da cui dipende
se cambia un file di quelli elencati, necessario rieseguire la
compilazione
Makefile - v2

CC = gcc

CFLAGS = -I. -Wall

LDFLAGS = -lm

myprog: liste.o utilities.o main.o

$(CC) -o myprog main.o liste.o utilities.o $(LDFLAGS)

clean:

rm *.o myprog

ancora una unica regola per la compilazione

regola per eliminare i file creati, eseguibile incluso


Makefile - v3

CC = gcc

INCLUDE = -I.

CXXFLAGS = -Wall

LDFLAGS = -lm

OBJS = liste.o utilities.o

all: myprog

myprog: $(OBJS)

$(CC) $(CXXFLAGS) $(OBJS) -o myprog main.c $(INCLUDE)


$(LDFLAGS)

liste.o : liste.c

$(CC) $(CXXFLAGS) -o liste.o -c liste.c $(INCLUDE)

utilites.o : utilities.c

$(CC) $(CXXFLAGS) -o utilities.o -c utilities.c $(INCLUDE)


Makefile - v4

CC = gcc

INCLUDE = -I.

CXXFLAGS = -Wall

LDFLAGS = -lm

OBJS = liste.o utilities.o main.o

all: myprog $(OBJS)

%.o : %.c

$(CC) $(CXXFLAGS) -c -o $@ $< $(INCLUDE)

myprog: $(OBJS)

$(CC) $(CXXFLAGS) -o $@ $^ $(INCLUDE) $(LDFLAGS)

clean:

rm *.o myprog