[c++] trasformare function in file esterni

[vermaccio]

Ho scritto un listato c++.
è composto, come al solito, da una prima parte dichiarativa delle variabili , degli include etc etc, seguono poi MOLTE function che ho scritto ed infine il main che le usa.

poichè queste function iniziano ad esere davvero tante, è possibile metterle in un file esterno .cpp in modo che compilando vengano però fuse nel .exe che verrà creato così come avviene ora?

mi spiego.

ORA
----

file .cpp mastodontico (main+functions)

compilazione --> file .exe

VORREI
--------

file .cpp piccolo e leggero (solo main)
file .cpp 1 function1
file .cpp 2 function2
...
file .cpp n function n

compilazione ---> file .exe unico


come faccio?


esempio

#include<stdio.h>
#include <math.h>

double C [6][4];
double A [6][3]= { {1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}, {13, 14, 15}, {16, 17, 18} }; 
double B [3][4]= { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };
double test;
int i,j,k;
double righeA, colonneA, righeB, colonneB;





//funzione
void prodottomatrici(double matA[6][3], double righeA, double colonneA  , double matB[3][4], double righeB, double colonneB, double matC[6][4])  {

//i=righeA
//j=colonneB)
//k=colonneA=righeB

for (i=0; i<righeA; i++){
	for (j=0; j<colonneB; j++){
		matC[i][j]=0;
			for (k=0; k<3; k++){
				matC[i][j]=matC[i][j]+matA[i][k]*matB[k][j];
				//test=A[i][k]*B[k][j];
				//printf("%g\n", test );
							}
            printf("%g\n", matC[i][j] );
			}
	}
}



//--------------------
void main(void)
{

prodottomatrici(A,6,3,B,3,4,C);

//stampa a video 2 elementi per test
printf("elemento C[1][1]: %g\n", C[0][0] );
printf("elemento C[4][4]: %g\n", C[3][3] );
//deve venire 38 e 272




}

come faccio a mettere in un file a parte .cpp la function "prodottomatrici"?

NOTA: ho detto di mettere le function in file .cpp a parte ma poi non so se saranno file .cpp o che altro. questo me lo dovete dire voi.



nota2: se si può fare, quanto incide sull'esecuzione del programma coimpilato? è la stessa cosa avere il main mastodontico o le function separate? cioè compilando nei 2 casi verranno fuse allo stesso modo nell'.exe?

[Riordian]

per farla breve perchè purtroppo ora non ho tempo, devi creare dei .h con lo stesso nome dei.cpp con le dichiarazioni delle funzioni implementate nei .cpp, per poi includerli nel file principale con l'istruzione #include "file1.h"
Appena ho un po' di tempo, se nessuno ti risponde, te lo spiego meglio .

La leggibilità del codice ne risente in maniera molto positiva, ciao

[vermaccio]

appena hai tempo illuminami meglio con un esempio pratico.


in particolare potresti chiarirmi:

1)funziona anche se io passo alla function come ingressi dei puntatori e non delle variabili?

es: se ho funzione definita

void prodottomatrici(double *matrA, int nrigA, int ncolA, double *matrB, int nrigB, int ncolB, double *matrC, int nrigC, int ncolC) {

bla bla bla

}

e nel main
prodottomatrici (&C[0][0], 4, 3, &G[0][0], 3, 3, &E[0][0], 4, 3);

come faccio?




2)mettere in esterno le funzioni non crea "casini"? insomma non è che se una funzione ne chiama un altra poi non la vede?
es:

funzione1
funzione2 che usa la funzione 1
funzione3 che usa la funzione 2
funzione4 che usa la funzione 1 e la 3
funzione5
main

le funzioni 1 e 5 funzionano a se stanti ma le altre funzioni ne richiamano altre.

come le stacco?



3) se la funzione restituisce un risultato (es: un numero double) a fine function lascio sempre il return(variabileuscita); o devo modificare?

4) la visibilità delle variabili (globali, locali,...) è identica al caso di progarmma mastodontico unico?

5) che "svantaggi" ho nello scomporre il programma in questo modo?

[Riordian]

Originariamente inviato da vermaccio

appena hai tempo illuminami meglio con un esempio pratico.


in particolare potresti chiarirmi:

1)funziona anche se io passo alla function come ingressi dei puntatori e non delle variabili?

es: se ho funzione definita

void prodottomatrici(double *matrA, int nrigA, int ncolA, double *matrB, int nrigB, int ncolB, double *matrC, int nrigC, int ncolC) {

bla bla bla

}

e nel main
prodottomatrici (&C[0][0], 4, 3, &G[0][0], 3, 3, &E[0][0], 4, 3);

come faccio?

?

Come fai per tutte le altre funzioni quindi:

crei un file1.h in cui hai:
void prodottomatrici(double *matrA, int nrigA, int ncolA, double *matrB, int nrigB, int ncolB, double *matrC, int nrigC, int ncolC);


crei un file1.cpp con:

#include "file1.h"
void prodottomatrici(double *matrA, int nrigA, int ncolA, double *matrB, int nrigB, int ncolB, double *matrC, int nrigC, int ncolC) {

bla bla bla

}
poi nel <file del main>.cpp:
#include "file1.h"

e nel corpo del main:

prodottomatrici (&C[0][0], 4, 3, &G[0][0], 3, 3, &E[0][0], 4, 3);
[/quote]

2)mettere in esterno le funzioni non crea "casini"? insomma non è che se una funzione ne chiama un altra poi non la vede?
es:

funzione1
funzione2 che usa la funzione 1
funzione3 che usa la funzione 2
funzione4 che usa la funzione 1 e la 3
funzione5
main

le funzioni 1 e 5 funzionano a se stanti ma le altre funzioni ne richiamano altre.

come le stacco?

la regola che devi seguire è quella che ti ho descritto sopra, crei i file e dividi le funzioni come meglio credi, nei file dove viene chiamata una determinata funzione includi il punto .h necessario.
Per come metterle nei file devi decidere un criterio te. Per esempio puoi decidere di dividerle in base alle operazioni che fanno o alla loro complessità o altri criteri

3) se la funzione restituisce un risultato (es: un numero double) a fine function lascio sempre il return(variabileuscita); o devo modificare?

lasci sempre il return

4) la visibilità delle variabili (globali, locali,...) è identica al caso di progarmma mastodontico unico?

La visibilità delle variabile funziona sempre allo stesso modo.
Se una variabile deve essere utilizzata in file diversi la devi dichiarare in un .h che poi verra incluso con il solito #include nei .cpp che la utilizzano se la dichiari in un cpp la visibilità sarà per quel file ecc. ecc.

5) che "svantaggi" ho nello scomporre il programma in questo modo?

Mah, secondo me svantaggi non ce ne sono, i progetti che faccio io sono sempre composti da più file, quando la complessità del progetto aumenta è necessario snellire il codice tramite raggruppamenti in dll e file diversi.
Spero di esserti stato di aiuto è da un po' che non programmo in c e c++. Ciao

[vermaccio]

Originariamente inviato da Riordian

Come fai per tutte le altre funzioni quindi:

crei un file1.h in cui hai:
void prodottomatrici(double *matrA, int nrigA, int ncolA, double *matrB, int nrigB, int ncolB, double *matrC, int nrigC, int ncolC);


crei un file1.cpp con:

#include "file1.h"
void prodottomatrici(double *matrA, int nrigA, int ncolA, double *matrB, int nrigB, int ncolB, double *matrC, int nrigC, int ncolC) {

bla bla bla

}
poi nel <file del main>.cpp:
#include "file1.h"

e nel corpo del main:

prodottomatrici (&C[0][0], 4, 3, &G[0][0], 3, 3, &E[0][0], 4, 3);

[/quote]


quindi devo avere:

1) il file main.cpp in cui ho solo il main e le eventuali function che non ho tirto fuori e messo a parte
2)una serie di funzioni"esterne" composte da 2 file: se ho n funzioni esterne avrò 2*n filein più:

2a)n file chiamati qualcosa_n.h in cui ho solo l'intestazione
2b) n file chiamati qualcosa_n.cpp in cui ho il corpo della funzione



es:
in 2a)avrò:
void prodottomatrici(double *matrA, int nrigA, int ncolA, double *matrB, int nrigB, int ncolB, double *matrC, int nrigC, int ncolC);

in 2b) avrò:
#include "file1.h"
void prodottomatrici(double *matrA, int nrigA, int ncolA, double *matrB, int nrigB, int ncolB, double *matrC, int nrigC, int ncolC) {


e nel main avrò:
#include "file1.h"

e nel corpo del main:

prodottomatrici (&C[0][0], 4, 3, &G[0][0], 3, 3, &E[0][0], 4, 3);


quindi se ho il main e 5 funzioni estratte avrò 1 main .cpp + 5 .h +5 .cpp cioè in totale 11 file e non 6.

ho capito bene?

[Riordian]

Originariamente inviato da vermaccio

quindi devo avere:

1) il file main.cpp in cui ho solo il main e le eventuali function che non ho tirto fuori e messo a parte
2)una serie di funzioni"esterne" composte da 2 file: se ho n funzioni esterne avrò 2*n filein più:

2a)n file chiamati qualcosa_n.h in cui ho solo l'intestazione
2b) n file chiamati qualcosa_n.cpp in cui ho il corpo della funzione



es:
in 2a)avrò:
void prodottomatrici(double *matrA, int nrigA, int ncolA, double *matrB, int nrigB, int ncolB, double *matrC, int nrigC, int ncolC);

in 2b) avrò:
#include "file1.h"
void prodottomatrici(double *matrA, int nrigA, int ncolA, double *matrB, int nrigB, int ncolB, double *matrC, int nrigC, int ncolC) {


e nel main avrò:
#include "file1.h"

e nel corpo del main:

prodottomatrici (&C[0

[0], 4, 3, &G[0][0], 3, 3, &E[0][0], 4, 3);


quindi se ho il main e 5 funzioni estratte avrò 1 main .cpp + 5 .h +5 .cpp cioè in totale 11 file e non 6.

ho capito bene?

direi di si, comunque non è che se hai 5 funzioni devi per forza avere 5 file.h e 5 .cpp puoi anche raggrupparle tutte in un file o dividerle in 2 o 3 file, dipende tutto da come preferisci organizzare il progetto, cmq mi sembra che il metodo lo hai capito bene