Risposta.

Storicamente, la modularità è emersa come un modo per suddividere grandi progetti in parti logiche indipendenti per migliorare la leggibilità, il riutilizzo del codice e la suddivisione delle responsabilità tra gli sviluppatori. In C, la modularità è realizzata a livello di file — file sorgente (.c) e file header (.h).

Il problema con cui si confrontano i programmatori è: come organizzare l'interazione tra le parti di codice, evitare la duplicazione delle definizioni, non violare l'incapsulamento e semplificare la compilazione.

La soluzione è utilizzare la separazione tra interfaccia e implementazione:

Nel file .h si dichiarano le funzioni esterne, i tipi, le strutture.
Nel file .c si fornisce l'implementazione.
Per le variabili globali si utilizza extern.
Per le entità "private" — static.

Esempio di struttura di codice modulare:

// mymath.h
#ifndef MYMATH_H
#define MYMATH_H
int add(int, int);
#endif

// mymath.c
#include "mymath.h"
int add(int a, int b) { return a + b; }

// main.c
#include "mymath.h"
#include <stdio.h>
int main() {
    printf("%d\n", add(3, 4));
    return 0;
}

Caratteristiche chiave:

Chiara separazione tra interfaccia (.h) e implementazione (.c).
Utilizzo di static per nascondere l'implementazione.
extern consente di condividere variabili e funzioni tra i moduli.

Domande insidiose.

È possibile definire una variabile con extern in un file header e utilizzarla in sicurezza in più moduli?

No! Le variabili globali devono essere definite solo in un file .c, mentre nei file header devono essere solo dichiarate tramite extern. Altrimenti si verificheranno errori di collegamento a causa di "multiple definition".

È obbligatorio includere ogni file header tramite #include solo una volta?

È necessario avvolgere ogni file .h con guardie di inclusione (#ifndef/#define/#endif), altrimenti, in caso di inclusione ripetuta, si verificherà un conflitto di dichiarazioni e errori di compilazione.

È possibile implementare un'incapsulazione completa dei dati privati di una struttura (opaque pointer) in C?

Sì. Il cosiddetto "opaque pointer" consente di nascondere i dettagli della struttura all'utente:

// mystruct.h
typedef struct MyStruct MyStruct;
MyStruct* create(void);
void destroy(MyStruct*);

// mystruct.c
struct MyStruct { int a; };

Errori comuni e anti-pattern

Confusione tra dichiarazione e definizione delle variabili.
Mancanza di include guards.
Violazione dell'incapsulamento (esposizione di dettagli privati nell'header).

Esempio dalla vita reale

Caso negativo

Tutta la logica è implementata in un lungo file .c, il codice è ripetuto, le variabili globali si sovrappongono, si verificano errori di collegamento.

Vantaggi:

Prototipazione rapida.

Svantaggi:

Scarsa manutenibilità, rischio di conflitti, difficoltà di debug.

Caso positivo

Il codice è decomposto in moduli, vengono utilizzate include guards, i dati privati sono nascosti tramite opaque pointer.