[c] compilazione complessa

[esoni]

ciao ragazzi
ho visto che se ho un programma main.c che include lib.h devo fare le seguenti cose:
-genero lib.o
-converto lib.o in lib.a
-quando compilo main.c gli passo lib.a

ma ora se la cosa si fa piu complessa:
main.c include lib.h
lib.h include a sua volta pila.h
che faccio ora?

io penso
-genero pila.o
-lo connverto in pila.a
-compilo lib.c passandogli pila.a, generando lib.o
-trasformo lib.o in lib.a
-compilo main.c passandogli e basta lib.a ??

[MItaly]

Perché fai il passaggio intermedio del .a? Basta compilare tutti i file in .o e poi linkarli assieme...

[oregon]

C'è qualche problema ... in realtà mancano

lib.c
pila.c

che sono i file che contengono il codice per generare le librerie (le .a).

I .h sono semplici file header, non contengono l'implementazione.

[esoni]

riepilogo
ho main.c che include lib.h
lib.h include a sua volta pila.h

nella dir ci sono anche ovviamente lib.c e pila.c...
qualcuno mi sa suggerire la compilazione?

[oregon]

Se ci dicessi anche quale compilatore/ambiente usi, sarebbe meglio.

In ogni caso, devi indicare al compilatore (o all'IDE tramite l'impostazione di un progetto) semplicemente che devi compilare insieme i moduli main.c, lib.c e pila.c

Niente altro

[esoni]

uso gcc

[Laikius91]

Originariamente inviato da esoni
uso gcc

Ma allora è tutto molto più semplice...
Nella directory del progetto tu hai : main.c, lib.c, pila.c, lib.h, pila.h giusto?

Allora basta che da terminale esegui:

gcc -o nomeDelProgramma *.c

In questo modo gli dici di crearti l'eseguibile di nome "nomeDelProgramma" , utilizzando tutti i file .c (*.c) che ci sono nella directory (ovviamente ti devi essere spostato lì prima!).
Le inclusioni degli header vengono fatte in automatico a compile-time con le direttive (#INCLUDE)!
Così ti salti tutta la creazione dei file .o ecc ecc e hai subito l'eseguibile!

[esoni]

wow !
quindi quando vogliamo testare l intero sistema(formati da piu moduli) conviene sempre fare come hai detto te?
mentre quando testiamo i singoli moduli gli specifichiamo al compilatore le cose da compilare

[oregon]

Direi che è sempre meglio indicare i moduli da compilare.

Potresti anche usare un makefile.

Se utilizzassi un IDE, sarebbe anche meglio.

[MItaly]

A tal proposito, agevolo il mio "Makefile dell'uomo pigro", che unisce i vantaggi del metodo "rozzo" gcc *.c (compila tutti i file presenti della directory corrente) a quelli del makefile (gestisce le dipendenze e non vengono ricompilati i file già aggiornati):

# eseguibile di output
OUTPUT = out #TODO: inserire qui il nome dell'eseguibile di output
# librerie
LIBS = #TODO: inserire i parametri le librerie da linkare
# percorsi aggiuntivi per gli header
INCS = #TODO: inserire i parametri per i percorsi aggiuntivi per gli header
# compilatore C
CC = gcc
# flag per il compilatore
CCFLAGS = -O3 -Wall -Wextra -ansi -pedantic $(LIBS) $(INCS)
# flag per fargli generare i file delle dipendenze
DEPFLAGS = -MMD -MF $@.d
# sorgenti - di default pesca tutti i .c della directory
SRCS = $(wildcard *.c)
# oggetti => ricavati rimpiazzando il .c con .o
OBJECTS = $(patsubst %.c,%.o,$(SRCS))
# file di dipendenze => ricavati dagli oggetti aggiungendoci .d
# e verificandone l'esistenza
DEPS = $(wildcard $(foreach f,$(OBJECTS),$(f).d))

# target di default: dipende dall'eseguibile finale
all: $(OUTPUT)

# genera il programma finale, richiedendo tutti gli oggetti
$(OUTPUT): $(OBJECTS)
	$(CC) $(CCFLAGS) $(OBJECTS) -o $(OUTPUT)
	
# elimina gli oggetti, l'output, i file delle dipendenze
clean:
	rm -f $(OBJECTS)
	rm -f $(OUTPUT)
	rm -f $(DEPS)

# crea il .tar
tar: clean
	tar -czf ../`basename $(CURDIR)`.tar.gz -C .. `basename $(CURDIR)`

# include i file di dipendenze generati dal compilatore; consente di
# ottenere le dipendenze tra i vari .c e i .h senza impazzire
include $(DEPS)

# regola generica per generare i .o: dipende dal relativo .c e lo compila
# con i flag adeguati
%.o: %.c
	${CC} ${CCFLAGS} ${DEPFLAGS} -c -o $@ $<