[C] Dividere un programma: headers e sorgenti

[salvodel]

Salve a tutti, volevo chiedervi come organizzare il mio programma. Essendo diventato un po lungo avevo pensato di dividerlo ma credo di non averlo fatto nel modo corretto...perlomeno da quello che ho trovato in giro.
Al momento ho fatto cosi:
praticamente in sorgenteX.c ci sono le funzioni mentre in sorgenteX.h ci sono solo le intestazioni. Spero sia chiaro:rolleyes: riporto una pseudo struttura:
main()
{
#include <>
...
#include "sorgente1.h"
#include "sorgente2.h"
#include "sorgente3.h"
...
}

sorgente1.c
int funzione1(double var, int var1)
{
...
...
}
int funzione2(char var, char var1)
{
...
...
}
sorgente1.h

int funzione1(double var, int var1);
int funzione2(char var, char var1);
Inoltre poiché ho una struttura che devo utilizzare in tutte le funzioni, oggi ho creato un file header con la definizione della funzione e l'ho inserita in tutte le funzioni.

strutturadati.h
struct mydata {
double *var1;
double *var2;
double *var3;
double **var4;
double **var5;
};

[DanieleC88]

Perché includi degli header dentro la funziona main()? Devi farti dei moduli separati, uno per ogni file .c, ed in corrispondenza di ognuno devi definire ed esportare delle interfacce, una per ogni file .h, che elenchino tutte le funzioni di quel modulo (ovvero tutto ciò "che puoi fare" con quel modulo). Almeno, spero sia questo che volevi sapere, perché stasera sto un po' fuso, quindi potrei aver inteso male. :asd:

[salvodel]

Perché includi degli header dentro la funziona main()? Devi farti dei moduli separati, uno per ogni file .c, ed in corrispondenza di ognuno devi definire ed esportare delle interfacce, una per ogni file .h, che elenchino tutte le funzioni di quel modulo (ovvero tutto ciò "che puoi fare" con quel modulo). Almeno, spero sia questo che volevi sapere, perché stasera sto un po' fuso, quindi potrei aver inteso male. :asd:

Che intendi per interfacce? Potresti farmi qualche abbozzo di schema.
Grazie

[DanieleC88]

Intendo che, per esempio, in un file .c tu vuoi infilarci un modulo che si occupi di gestire una lampadina:
#include "lampadina.h"

typedef int tungsteno;
struct lampadina
{
tungsteno filamento;
};

void tungsteno_riscalda(tungsteno *);
void tungsteno_raffredda(tungsteno *);

void lampadina_accendi(lampadina p)
{
tungsteno_riscalda(&p->filamento);
}

void lampadina_spegni(lampadina p)
{
tungsteno_raffredda(&p->filamento);
}

void tungsteno_riscalda(tungsteno *p)
{
(*p) = 1;
}

void tungsteno_raffredda(tungsteno *p)
{
(*p) = 0;
}

Nel tuo file .h hai bisogno solo di "intefacciarti" con una lampadina, quindi che ci sia dentro del tungsteno (lampadine classiche, ad incandescenza) o che tu voglia poi farle evolvere in neon o lampade alogene è una cosa che all'utente del modulo non interessa: lui vuole una lampadina che si accenda e si spegna a comando.
Quindi esporterai solo l'interfaccia necessaria:
#ifndef LAMPADINA_H
#define LAMPADINA_H

struct lampadina;
typedef struct lampadina *lampadina;

void lampadina_accendi(lampadina);
void lampadina_spegni(lampadina);

#endif
E, come vedi, l'interfaccia ti definisce l'insieme delle operazioni che puoi o non puoi effettuare tramite quel modulo.

ciao ;)

[salvodel]

Intendo che, per esempio, in un file .c tu vuoi infilarci un modulo che si occupi di gestire una lampadina:
ciao ;)

Prima di tutto ti devo ringraziare per la lunga risposta che mi hai dato ma ahi me non ho capito….mi hai fatto l’esempio di una lampadina ma non mi si è acceso nulla:cry: . Stavo pensando di farti un esempio con quello che mi interessa e casomai provi a correggermi gli erroracci che faccio

programma.c
#include <stdio.h>
#include <stdlib.h>

#include "struttura.h"
#include "gruppo_funz1.h"
#include "gruppo_funz2.h"

int main()
{
int i;
struct mystruc data;

.....
inserisci_dati(&data);
ghirigori(&data);

return 1;
}

gruppo_funz1.c
#include <stdio.h>
#include <stdlib.h>

#include "struttura.h"

int inserisci_dati(struct mydata *data)
{
int i;
for(i=0;i<5;i++)
data->var1[i]=i;
for(i=0;i<5;i++)
data->var2[i]=10+i;
for(i=0;i<5;i++)
data->var3[i]=somma(data->var1[i], data->var2[i]);

return 1;
}
gruppo_funz1.h
int inserisci_dati(struct mydata *data);

gruppo_funz2.c
#include <stdio.h>
#include <stdlib.h>

#include "struttura.h"

int ghirigori(struct mydata *data)
{
int i;
for(i=0;i<data->var1[4];i++)
printf("Blaaa")
return 1;
}

int somma(int a, int b)
{
retutn a+b;
}

gruppo_funz2.h
int somma(int a, int b);
int ghirigori(struct mydata *data);

struttura.h
struct mystruc {
int *var1;
int *var2;
int *var3;
}

Come organizzeresti il tutto? Io l'ho organizzato cosi è credo che sia sbagliato...togli anche il credo visto che sotto linx non compila. Il problema è che con Visual Studio è andato ed allora pensavo sia di aver capito sia di aver fatto le cose bene. Potresti spiegarmelo con i file strutturati cosi come li ho scritti io senza mettere tutte le funzioni in uno solo, in modo che sia piu simile ai miei sorgenti veri?
Grazie mille.

PS
Spero di non aver scritto cavolate ma il problema non è nella sintassi di quello che ho scritto ma su come va strutturato un programma diviso su piu sorgenti. Questo per dirti di non stare li a correggere cavolate che ho scritto, data anche l'ora, ma di correggermi solo l'organizzazione. Di nuovo grazie.

[DanieleC88]

Non mi sembra che ci sia niente di "sbagliato", se non che negli header non hai scritto le formule magiche che ti evitano la rogna dell'inclusione multipla: come saprai, il preprocessore funziona per sostituzione diretta del testo, quindi se tu includi un .h in un file .c, non fai altro che ricopiarvi dentro le dichiarazioni e le definizioni. Questo però comporta che, se includi lo stesso file .h in più di un file .c (come stai facendo per struttura.h), stai esportando due volte gli stessi simboli di funzione.

Si risolve velocemente così:
/* Un generico header "mioheader.h" */
#ifndef MIOHEADER_H
#define MIOHEADER_H

/* Qui dentro ci va il normale contenuto dell'header, */
/* senza bisogno di modifiche. */

#endif
In questo modo definisci una macro alla prima inclusione dell'header, e alle successive non avrai niente più da includere, perché il preprocessore troverà la macro già definita (il controllo è su #ifndef).

Spero di averti chiarito le idee!
ciao ;)

[salvodel]

Non mi sembra che ci sia niente di "sbagliato", se non che negli header non hai scritto le formule magiche che ti evitano la rogna dell'inclusione multipla: come saprai, il preprocessore funziona per sostituzione diretta del testo, quindi se tu includi un .h in un file .c, non fai altro che ricopiarvi dentro le dichiarazioni e le definizioni. Questo però comporta che, se includi lo stesso file .h in più di un file .c (come stai facendo per struttura.h), stai esportando due volte gli stessi simboli di funzione.

Si risolve velocemente così:
/* Un generico header "mioheader.h" */
#ifndef MIOHEADER_H
#define MIOHEADER_H

/* Qui dentro ci va il normale contenuto dell'header, */
/* senza bisogno di modifiche. */

#endif
In questo modo definisci una macro alla prima inclusione dell'header, e alle successive non avrai niente più da includere, perché il preprocessore troverà la macro già definita (il controllo è su #ifndef).

Spero di averti chiarito le idee!
ciao ;)

Scusa se ti ringrazio solo ora ma ho avuto alcuni problemi. Cercherò di rifare tutto poiché continuo ancora ad avere dei problemi....:muro:
Grazie

[DanieleC88]

Che problemi ti sta dando ora? Vediamo se si può risolvere. :)