[C++] Errore di linking

[RooccoXXI]

Originariamente inviato da shodan
Può essere. Nei Makefile che scrivevo io non ho mai inserito un .h (erano molto semplici però)
Puoi fare un esempio veloce?

CC = g++gcc-4.6.x  
CXX = g++gcc-4.6.x  
CXXFLAGS = -std=c++0x

all: testVettore testPalla

# --- TEST VETTORE ---
testVettore: testVettore.o Vettore.o
testVettore.o: testVettore.cc Vettore.h

# --- TEST PALLA ---
testPalla: testPalla.o Gravita.o Palla.o
testPalla.o: testPalla.cc Gravita.h Palla.h

# --- CLASSI ---
Vettore.o: Vettore.h Vettore.cc

Palla.o: Palla.h Palla.cc Vettore.h

CampoForze.o: CampoForze.h CampoForze.cc Vettore.h Palla.h
Gravita.o: Gravita.h Gravita.cc CampoForze.h

# --- CLEAN ---
clean:
	rm -f *.o

Riprendendo il mio Makefile. La classe Gravita eredita da CampoForze, in Gravita avrò un include di "CampoForze.h" e questo lo specifico nel Makefile. La classe CampoForze ha un attributo di tipo Vettore e una funzione che prende Palla come argomento, quindi in CampoForze ho incluso "Vettore.h" e "Palla.h" e lo specifico nel Makefile. Così via per le altre classi. Anche i vari programmi di test (che contengono il main() ) devono essere compilati allo stesso modo (testPalla utilizza Gravita e Palla). Alla fine fai un linking di tutti i file .o che ti servono a compilare il main(), questo per ogni programma di test. E in all metti tutti i test che deve compilare (cioè tutti i linking che hai fatto per ogni test).

Spero di essere stato sufficientemente chiaro ed esplicito. Comunque sicuramente qualcuno saprà spiegarti meglio e magari illustrare anche le funzionalità più avanzate (che proprio non conosco).

[shodan]

Originariamente inviato da RooccoXXI
La classe Gravita eredita da CampoForze, in Gravita avrò un include di "CampoForze.h" e questo lo specifico nel Makefile

E' appunto questo che mi lascia perplesso.
Se in Gravita.cc fai:

include "CampoForze.h"

e in CampoForze.h fai:

#include "Vettore.h"
#include "Palla.h"

che bisogno c'è di metterli anche nel Makefile?

[RooccoXXI]

Originariamente inviato da shodan
E' appunto questo che mi lascia perplesso.
Se in Gravita.cc fai:

include "CampoForze.h"

e in CampoForze.h fai:

#include "Vettore.h"
#include "Palla.h"

che bisogno c'è di metterli anche nel Makefile?

Penso di aver capito il tuo dubbio: ti chiedi perché in Graita.o non aggiungo anche Vettore.h e Palla.h anche se in realtà sono inclusi dall'inclusione di CampoForze in Gravita?

Sinceramente non lo so.

[shodan]

Originariamente inviato da RooccoXXI
ti chiedi perché in Gravita.o non aggiungo anche Vettore.h e Palla.h anche se in realtà sono inclusi dall'inclusione di CampoForze in Gravita?

Non proprio. Io parlo degli include files scritti nei .cc reali, non in qualche rule del Makefile.

[MItaly]

Da come l'ho sempre capita io, si specificano gli include nelle dipendenze del Makefile per fare sì che, se vengono modificati gli include, anche i target che da essi dipendono tramite inclusione siano marcati come da ricompilare.

In ogni caso, l'ho sempre trovato un sistema tedioso e soggetto ad errori, per cui un giorno ho perso qualche ora per scrivere il "makefile definitivo" (per tutti i progetti universitari), che compila tutti i .cpp della directory corrente, gestendo le dipendenze automaticamente:

# eseguibile di output
OUTPUT = esercizio.x
# estensione per i file da compilare
CXXEXT = cpp
# flag librerie
LIBS = 
# percorsi aggiuntivi per gli header
INCS = 
# compilatore C++
CXX = g++
# flag per il compilatore
CXXFLAGS = -O3 -Wall -Wextra -ansi -pedantic
# flag per fargli generare i file delle dipendenze
DEPFLAGS = -MMD -MF $@.d
# sorgenti - di default pesca tutti i .cpp della directory
SRCS = $(wildcard *.${CXXEXT})
# oggetti => ricavati rimpiazzando il .cpp con .o
OBJECTS = $(patsubst %.${CXXEXT},%.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)

# target compito: richiama il default
compito: $(OUTPUT)

# genera il programma finale, richiedendo tutti gli oggetti
$(OUTPUT): $(OBJECTS)
	$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBS) -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 .cpp e i .hpp senza impazzire
include $(DEPS)

# regola generica per generare i .o: dipende dal relativo .cpp e lo compila
# con i flag adeguati
%.o: %.${CXXEXT}
	${CXX} ${CXXFLAGS} ${INCS} ${DEPFLAGS} -c -o $@ $<

Per il resto comunque in genere cerco di evitare i Makefile, trovo che altri sistemi (qmake, cmake) siano ben più comodi.

[shodan]

Originariamente inviato da MItaly
Da come l'ho sempre capita io, si specificano gli include nelle dipendenze del Makefile per fare sì che, se vengono modificati gli include, anche i target che da essi dipendono tramite inclusione siano marcati come da ricompilare.

Ma non dovrebbe avvenire in automatico?
Mi sa che dovrò fare una full immersion nel Makefile.

[MItaly]

Originariamente inviato da shodan
Ma non dovrebbe avvenire in automatico?

No, i makefile (almeno, quelli classici) non sono oggetti molto intelligenti, e di base credo che siano abbastanza "language agnostic"; nel momento in cui tu scrivi un obiettivo lui guarda solo le sue dipendenze esplicite.

Mi sa che dovrò fare una full immersion nel Makefile.

Da quello che mi è stato detto, cmake dovrebbe essere la versione intelligente dei makefile, probabilmente può essere più utile approfondire quelli...

[RooccoXXI]

Originariamente inviato da MItaly
Da come l'ho sempre capita io, si specificano gli include nelle dipendenze del Makefile per fare sì che, se vengono modificati gli include, anche i target che da essi dipendono tramite inclusione siano marcati come da ricompilare.

In ogni caso, l'ho sempre trovato un sistema tedioso e soggetto ad errori, per cui un giorno ho perso qualche ora per scrivere il "makefile definitivo" (per tutti i progetti universitari), che compila tutti i .cpp della directory corrente, gestendo le dipendenze automaticamente:

# eseguibile di output
OUTPUT = esercizio.x
# estensione per i file da compilare
CXXEXT = cpp
# flag librerie
LIBS = 
# percorsi aggiuntivi per gli header
INCS = 
# compilatore C++
CXX = g++
# flag per il compilatore
CXXFLAGS = -O3 -Wall -Wextra -ansi -pedantic
# flag per fargli generare i file delle dipendenze
DEPFLAGS = -MMD -MF $@.d
# sorgenti - di default pesca tutti i .cpp della directory
SRCS = $(wildcard *.${CXXEXT})
# oggetti => ricavati rimpiazzando il .cpp con .o
OBJECTS = $(patsubst %.${CXXEXT},%.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)

# target compito: richiama il default
compito: $(OUTPUT)

# genera il programma finale, richiedendo tutti gli oggetti
$(OUTPUT): $(OBJECTS)
	$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBS) -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 .cpp e i .hpp senza impazzire
include $(DEPS)

# regola generica per generare i .o: dipende dal relativo .cpp e lo compila
# con i flag adeguati
%.o: %.${CXXEXT}
	${CXX} ${CXXFLAGS} ${INCS} ${DEPFLAGS} -c -o $@ $<

Per il resto comunque in genere cerco di evitare i Makefile, trovo che altri sistemi (qmake, cmake) siano ben più comodi.

Se ho ben capito però con questo tuo Makefile puoi compilare un solo main() alla volta. Io spesso compilo tutti i test che ho fatto (quindi ho più .cc contenenti un main() ). Il tuo Makefile darebbe errore, giusto?

[MItaly]

Sì; è pensato giusto per piccoli progetti, con tutti i file di un solo progetto in un'unica cartella.

[RooccoXXI]

Originariamente inviato da MItaly
Sì; è pensato giusto per piccoli progetti, con tutti i file di un solo progetto in un'unica cartella.

Ok. Essendo il mio progetto comunque di piccole dimensioni mi trovo bene con il Makefile. Però ogni tanto di dimentichi una cosa (come aggiungere i .o) e perdi un sacco di tempo.. =S. Mi informerò su Cmake!