Quello che e`stato visto fin'ora costituisce sostanzialmente il sottoinsieme C del C++ (salvo l'overloading, i reference e altre piccole aggiunte), e` tuttavia sufficiente per poter realizzare un qualsiasi programma.
A questo punto, prima di proseguire, e` necessario soffermarci per esaminare il funzionamento del linker C++ e vedere come organizzare un grosso progetto in piu` file separati.



Linkage

Abbiamo gia` visto che ad ogni identificatore e` associato uno scope e una lifetime, ma gli identificatori di variabili, costanti e funzioni possiedono anche un linkage.
Per comprendere meglio il concetto e` necessario sapere che in C e in C++ l'unita` di compilazione e` il file, un programma puo` consistere di piu` file che vengono compilati separatamente e poi linkati (collegati) insieme per ottenere un file eseguibile. Quest'ultima operazione e` svolta dal linker e possiamo pensare al concetto di linkage sostanzialmente come a una sorta di scope dal punto di vista del linker. Facciamo un esempio:

    // File a.cpp
    int a = 5;

    // File b.cpp
    extern int a;

    int GetVar() {
        return a;
    }

    // File a.cpp
    int a = 5;

    int f(int c) {
        return a+c;
    }

    // File b.cpp
    extern int f(int);

    int GetVar() {
        return f(5);
    }

    // Contenuto file C++
    extern "C" int CFunc(char *);
    extern "C" char * CFunc2(int);

    // oppure per risparmiare
    extern "C" {
        void CFunc1(void);
        int * CFunc2(int, char);
        char * strcpy(char *, const char *);
    }

    extern Func2(int);

    int Func1(int c) {
        if (c==0) return 1;
        return Func2(c-1);
    }

    int Func2(int c) {
        if (c==0) return 2;
        return Func1(c-1);
    }

    // File 1.cpp
    enum Color { Red, Green, Blue };

    extern void f(Color);

    // File2.cpp
    enum Color { Red, Green, Blue };

    void f(Color c) { /* ... */ }

    // File a.cpp
    static int a = 5;        // linkage interno

    int f(int c) {           // linkage esterno
        return a+c;
    }

    // File b.cpp
    extern int f(int);

    static int GetVar() {    // linkage interno
        return f(5);
    }

    // Esempio.h
    enum Color { Red, Green, Blue };
    struct Point {
        float X;
        float Y;
    };

    const int Max = 1000;
        
    inline int Sum(int x, int y) {
        return x + y;
    }

    // Modulo1.cpp
    #include "Esempio.h"

    /* codice modulo */

   // Esempio2.h
    // dichiarazioni extern comuni ai moduli
    extern int a;
    extern double * Ptr;
    extern void Func();
    extern "C" {
        int CFunc1(int, float);
        void CFunc2(char *);
    }

    // Date.h
    struct Date {
        unsigned short dd;    // giorno
        unsigned short mm;    // mese
        unsigned yy;          // anno
        unsigned short h;     // ora
        unsigned short m;     // minuti
        unsigned short s;     // secondi
    };
        
    void PrintDate(Date);
    /* altre funzioni */

    // Date.cpp
    #include < Date.h >
    #include < iostream.h >

    void PrintDate(Date dt) {
        cout << dt.dd << '/' << dt.mm << '/' << dt.yy;
        cout << "       " << dt.h << ':' << dt.m;
        cout << ':' << dt.s;
    }

    /* implementazione di altre funzioni */

    // Modulo1.h
    #include < iostream.h >

    /* altre dichiarazioni */

    // Modulo2.h
    #include < iostream.h >

    /* altre dichiarazioni */

    // Main.cpp
    #include < iostream.h >
    #include < Modulo1.h >
    #include < Modulo2.h >

    void main() { /* codice funzione */ }

    // Contenuto del file iostream.h
    #ifndef __IOSTREAM_H
    #define __IOSTREAM_H

    /* contenuto file header */

    #endif

1. Il preprocessore inizia a elaborare il file per produrre un unico file compilabile;
2. Viene incontrata la direttiva #include < iostream.h > e il file header specificato viene elaborato per produrre codice;
3. A seguito delle direttive contenute inizialmente in iostream.h, viene definito il simbolo __IOSTREAM_H e prodotto il codice contenuto tra #ifndef __IOSTREAM_H e #endif;
4. Si ritorna al file Main.cpp e il precompilatore incontra #include < Modulo1.h > e quindi va ad elaborare Modulo1.h;
5. La direttiva #include < iostream.h > contenuta in Modulo1.h porta il precompilatore ad elaborare di nuovo iostream.h, ma questa volta il simbolo __IOSTREAM_H e` definito e quindi #ifndef __IOSTREAM_H fa si` che nessun codice venga prodotto;
6. Si prosegue l'elaborazione di Modulo1.h e viene generato l'eventuale codice;
7. Finita l'elaborazione di Modulo1.h, la direttiva #include < Modulo2.h > porta all'elaborazione di Modulo2.h che e` analoga a quella di Modulo1.h;
8. Elaborato anche Modulo2.h, rimane la funzione main() di Main.cpp che produce il corrispondente codice;
9. Alla fine il precompilatore ha prodotto un unico file contenete tutto il codice di Modulo1.h, Modulo2.h e Main.cpp senza alcuna duplicazione e contenente tutte le dichiarazioni e le definizioni necessarie;
10. Il file prodotto dal precompilatore e` passato al compilatore per la produzione di codice oggetto;