[C] Piccolo problema con gli #include

[Lazy Bit]

Ciao a tutti,

ho suddiviso un programma su più file, ma al momento della compilazione sembra che gli #include non includano come dovrebbero. Il discorso è un po' contorto, ma cercherò di spiegarmi meglio:

Il sorgente è costituito da un file_principale.c e un file_principale.h, entrambi nella stessa directory.

In file_principale.c è presente un #include "supporto.h", con il quale è mia intenzione caricare sia supporto.h sia il relativo supporto.c (contentente funzioni e definizioni di tipo usate da file_principale.c). Infine, in main.c, scrivo solo #include "file_principale.h". Beh, quando compilo il progetto tutti i file sopracitati sono inclusi, ma il file_principale.c non riconosce le definizioni e le funzioni presenti in supporto.c... Per quale motivo? :help:


main.c -----> #include "file_principale.h"

file_principale.c -----> #include "supporto.h"

main.c non riconosce le funzioni e i tipi definiti in supporto.c

[__ZERO_UNO__]

in supporto.h definisci l'interfaccia delle funzioni di supporto ed eventuali classi e attributi. Includi il file supporto.h dal file supporto.c e definisci le funzioni. In file_principale.h includi il file header supporto.h e definisci l'interfaccia delle funzioni principali ecc. In file_principale.c includi il file file_principale.h. In main.c includi file_principale.h.
Utilizza le guardie.

supporto.h

#ifndef _SUPPORTO_H_
#define _SUPPORTO_H_ 1
// ...

#endif

supporto.c

#include "supporto.h"
// ...

file_principale.h

#ifndef _FILEPRINCIPALE_H_
#define _FILEPRINCIPALE_H_ 1
#include "supporto.h"
// ...
#endif

file_principale.c

#include "file_principale.h"
// ...

Ciao

[Lazy Bit]

Ma se scrivo #include "supporto.h" nel file principale non dovrebbe caricarmi automaticamente anche il relativo supporto.c? Sapevo così, eppure mi dà errore... Comunque grazie mille! Adesso funziona :)

[bender86]

Ma se scrivo #include "supporto.h" nel file principale non dovrebbe caricarmi automaticamente anche il relativo supporto.c? Sapevo così, eppure mi dà errore... Comunque grazie mille! Adesso funziona :)

No. La direttiva del preprocessore #include<nomefile> si limita a copiare pari pari il file nomefile nel file corrente (eventualmente espandendo altre direttive del preprocessore). Il contenuto di nomefile, o se esista un nomefile.c, è completamente irrilevante.
In C++ per usare una funzione (o classe, variabile...) devi averla prima dichiarata nello stesso file. Per semplificare le cose si usano le direttive #include<>, così puoi scrivere la dichiarazione una volta per tutte in un file .h e includere quel file dove usi quella funzione.
Potresti anche non includere mai nessun file e ripetere ogni volta i prototipi delle funzioni e le dichiarazioni delle classi che usi, ma ovviamente è scomodissimo (soprattutto se modifichi una classe devi ripetere la modifica in ogni file).

@__ZERO_UNO__
In C++ tutti i nomi che iniziano con underscore seguiti da una lettera maiuscola sono riservati, non si possono usare, quindi le tue guardie di inclusione non vanno bene. Meglio usare:
#ifndef SUPPORTO_H
#define SUPPORTO_H
// ...
#endif
o ancora meglio:
#ifndef NOMEPROGETTO_SUPPORTO_H
#define NOMEPROGETTO_SUPPORTO_H
// ...
#endif

[__ZERO_UNO__]

Non lo sapevo. Ho controllato, hai ragione.
Grazie.

[Lazy Bit]

No. La direttiva del preprocessore #include<nomefile> si limita a copiare pari pari il file nomefile nel file corrente (eventualmente espandendo altre direttive del preprocessore). Il contenuto di nomefile, o se esista un nomefile.c, è completamente irrilevante.

Credo che in parte abbia anch'io ragione. Infatti, se in main.c includo supporto.h (quest'ultimo contenente solo i prototipi di funzione), automaticamente è caricato supporto.c (che contiene le definizioni). Questo è sicuro (provare per credere)!

Sembra, però, che la cosa funzioni solo "al primo livello di inclusione", nel senso che se in supporto.c includo un altro file d'intestazione .h, il meccanismo a catena non funziona più, quindi mi ritrovo ad includere un file.c...

[bender86]

Credo che in parte abbia anch'io ragione. Infatti, se in main.c includo supporto.h (quest'ultimo contenente solo i prototipi di funzione), automaticamente è caricato supporto.c (che contiene le definizioni). Questo è sicuro (provare per credere)!

No, è sicuro che se includi supporto.h includi solo supporto.h, nient'altro (con ovviamente i file inclusi in supporto.h). Dovresti spiegare cosa intendi con "caricato".
Quando usi una funzione non ti serve la sua definizione, basta la dichiarazione (il prototipo). Sarà poi il linker a trovare la definizione tra tutte le unità di compilazione (puoi anche provare a scrivere solo un prototipo, la compilazione andrà a buon fine ma il linker darà errore).