Newsgroup: it.comp.lang.c++
Titolo: Come faccio a dividere un sorgente su più files?

Salve a tutti, ancora un altra domanda.
Spesso ho postato in questo NG messaggi in cui chiedevo delle inclusioni di
files .cpp fatte con #include.....mi acete fatto notare che non č una buona
regola di programmazione...
Ma allora alla domanda del subject cosa mi rispondete?
Non posso definire alcune classi in un file, altre classi su altri file e
poi includere?
Col C lo facevo e non mi ha mai dato casini
Bye
:--)))))

 Ma allora alla domanda del subject cosa mi rispondete?
Devi tenere separate le dichiarazione dalle definizioni. Una dichiarazione
indica che nel tuo programma esiste un elemento con un determinato nome (una
variabile, un oggetto, una funzione...) e che i riferimenti a tale nome devono
essere considerati validi dal compilatore, perchè verrano poi linkati con altri
file compilati in cui sono definite le stesse.
Esempio:
// include.h
extern int a;
void func (int a);
class cl
{
public:
    void qualche_funzione_membro();
private:
    int qualche_variabile_privata;
};
/////
Tutte quelle sopra sono dichiarazioni. Ora supponiamo che tu voglia utilizzare
le variabili, le classi e le funzioni sopra descritte:
// main.cpp
#include "include.h"
int main()
{
    a = 5;
    func(a);
    cl classe;
    classe.qualche_funzione_membro();
    return 0;
}
//
Se provi a compilare il file main (perchè non ha senso compilare i file .h da
soli) tutto funziona, ma quando arrivi al linker questo non riuscira' a trovare
la definizione delle funzioni, delle variabili e della classe, e ti sommergerà
di errori. Così devi ovviamente fare anche
// implement.cpp
#include "include.h"
#include <iostream>
int a;
void func (int a)
{
    std::out << a;
}
cl::cl()
: qualche_variabile_privata(0)
{
}
void cl::qualche_funzione_membro()
{
    std::out << "Qualche funzione membro" << std::endl;
}
////
Ora compili anche il file implement.cpp e poi fai un link dei due file obj che
ottieni come risultato.
Ciao Fbf.

 Col C lo facevo e non mi ha mai dato casini
mmhh... mai sentito parlare del linker?!
Quello che proponi di fare tu è "far creare al compilatore" un unico file a
partire da tanti file (col metodo degli #include).
Invece si tratta di fare tanti file separati, compilarli *separatamente* e
poi linkarli insieme. E' molto meglio.
Daniele.

Non ho ben capito se è questa istruzione che mi fa il linkaggio
std::out << "Qualche funzione membro" << std::endl;
Scusate se sono una patata di C++, ma devo iniziare a capirci qualcosa anche
io..... anche perchè sui libri queste cose non le spiegano.

 std::out << "Qualche funzione membro" << std::endl;
Ehm... questa istruzione ti stampa sullo std output (sul video) la stringa
"Qualche funzione membro".
Temo di non aver ben capito la tua domanda.
Però se non hai ben capito come funziona la compilazione/linkaggio dei
programmi posso spiegarti brevemente i passaggi.
Di norma si scrivono DUE file per ogni classe del tuo programma. Un file
.cpp ( o .cc ) e un file .h
Nel file .h metti la dichiarazione della classe (cioè scrivi quali funzioni
membro e quali data-member deve avere la tua classe).
Nel file .cpp metti l'implementazione delle member-function. Nel file .cpp
devi includere il file .h scritto precedentemente.
Tipicamente avrai poi un altro file .cpp in cui scriverai la funzione main()
che sarà l'entry del tuo programma.
Successivamente si tratta di "compilare" ogni file .cpp separatamente. Per
ogni file .cpp compilato ottieni un file .obj oppure .o
Il passo finale per ottenere l'eseguibile è il linkaggio. Linkando tra loro
tutti i file .obj ottieni il tuo file .exe
Come si fa per compilare/linkare i sorgenti? Ti faccio l'esempio di un
compilatore free: il gcc (ma tutti i compilatori si comportano in modo
analogo).
Per compilare un file pippo.cpp e ottenere così il file pippo.o si usa:
    g++ -c pippo.cpp
per linkare tra di loro i file pippo.o e pluto.o ottenendo prova.exe si usa:
    g++ -o prova.exe pippo.o pluto.o
Spero di aver dissipato i tuoi dubbi...
Daniele.
-----------------------
#exclude <windows.h>

 std::out << "Qualche funzione membro" << std::endl;
???
Il linker è un programma esterno e non mi risulta che possa essere
lanciato dal programma stesso che deve linkare. :-)
EMG

Thank you very much!!
Col gcc ci ho lavorato anche io, il problema è che non ho la documentazione
del Borland e che il BC5 ha un approccio grafico.
Comunque credo di aver capito forse come si deve fare.... io ci provo.

 Comunque credo di aver capito forse come si deve fare.... io ci provo.
Se sai come funzionano i makefile, io ti consiglio vivamente di usare make
anzichč i gestori di proggetti degli ambienti RAD.
Dovrebbe avere l'utility make pure il BC, come tutti i compilatori, se
ricordo bene.
Il buon motivo per usare i makefile anziché i gestori di proggetto č che le
dipendenze non sono generalmente gestite in modo corretto. Ad esempio, non
vengono mai incluse le dipendenze degli header file, cosě se tu cambi
qualcosa in un header file e poi compili, non succede niente.
Inoltre, usando un makefile il tuo proggetto diventa molto piů portabile.
Daniele.