Ho un compito da svolgere a casa e devo valutare quale approccio è migliore secondo la "Variazione protetta" di GRASP. Ho trovato una domanda su Stack Overflow sulla separazione dei file di intestazione e di codice in C ++ .

Tuttavia, ciò che voglio sapere perché Java non segue C ++ nel promuovere la separazione tra definizioni di classe e implementazioni di classe. Ci sono dei vantaggi con il metodo Java, rispetto al metodo C ++?

Quante righe di codice ci sono nel seguente programma?

#include <iostream>

int main()
{
   std::cout << "Hello, world!\n";
   return 0;
}

Probabilmente hai risposto 7 (o 6 se non hai contato la riga vuota o 4 se non hai contato le parentesi graffe).

Il tuo compilatore, tuttavia, vede qualcosa di molto diverso:

~$ cpp hello.cpp | wc
  18736   40822  437015

Sì, questo è 18.7 KLOC solo per un "Ciao, mondo!" programma. Il compilatore C ++ deve analizzare tutto ciò. Questo è uno dei motivi principali per cui la compilazione C ++ richiede così tanto tempo rispetto ad altre lingue e perché i linguaggi moderni evitano i file di intestazione.

Una domanda migliore sarebbe

Perché non C ++ ha file header?

C ++ è stato progettato per essere un superset di C, quindi ha dovuto conservare i file header per la compatibilità con le versioni precedenti.

OK, allora perché C ha i file header?

A causa del suo primitivo modello di compilazione separato. I file oggetto generati dai compilatori C non includono alcuna informazione sul tipo, quindi per evitare errori di tipo è necessario includere queste informazioni nel codice sorgente.

~$ cat sqrtdemo.c 
int main(void)
{
    /* implicit declaration int sqrt(int) */
    double sqrt2 = sqrt(2);
    printf("%f\n", sqrt2);
    return 0;
}

~$ gcc -Wall -ansi -lm -Dsqrt= sqrtdemo.c
sqrtdemo.c: In function ‘main’:
sqrtdemo.c:5:5: warning: implicit declaration of function ‘printf’ [-Wimplicit-function-declaration]
sqrtdemo.c:5:5: warning: incompatible implicit declaration of built-in function ‘printf’ [enabled by default]
~$ ./a.out 
2.000000

L'aggiunta delle dichiarazioni del tipo corretto risolve il bug:

~$ cat sqrtdemo.c 
#undef printf
#undef sqrt

int printf(const char*, ...);
double sqrt(double);

int main(void)
{
    double sqrt2 = sqrt(2);
    printf("%f\n", sqrt2);
    return 0;
}

~$ gcc -Wall -ansi -lm sqrtdemo.c
~$ ./a.out 
1.414214

Si noti che non ci sono #includes. Ma quando si utilizza un gran numero di funzioni esterne (che la maggior parte dei programmi farà), dichiararle manualmente diventa noioso e soggetto a errori. È molto più facile usare i file header.

In che modo le lingue moderne sono in grado di evitare i file header?

Utilizzando un diverso formato di file oggetto che include informazioni sul tipo. Ad esempio, il formato file Java * .class include "descrittori" che specificano i tipi di campi e i parametri del metodo.

Questa non era una nuova invenzione. In precedenza (1987), quando Borland aggiunse "unità" compilate separatamente a Turbo Pascal 4.0, scelse di utilizzare un nuovo *.TPUformato anziché Turbo C *.OBJper eliminare la necessità di file di intestazione.

Java ha interfacce per definire un contratto. Ciò fornisce un livello più elevato di astrazione rispetto alle esigenze del chiamante e all'attuazione effettiva. cioè il chiamante non deve conoscere la classe di implementazione, deve solo conoscere il contratto che supporta.

Supponi di voler scrivere un metodo che rallenta tutta la chiave / i valori in una mappa.

public static <K,V> void printMap(Map<K,V> map) {
    for(Entry<K,V> entry: map.entrySet())
        System.out.println(entry);
}

Questo metodo può chiamare entrySet () su un'interfaccia astratta che viene rimossa dalla classe che la implementa. Puoi chiamare questo metodo con.

printMap(new TreeMap());
printMap(new LinkedHashMap());
printMap(new ConcurrentHashMap());
printMap(new ConcurrentSkipListMap());

Le intestazioni esistono, francamente, come un incidente storico. È un sistema incredibilmente povero, nessun'altra lingua ha qualcosa di così terribile e chiunque non debba affrontarli dovrebbe rallegrarsi.

Le intestazioni sono lì per consentire la compilazione separata. Includendo # le intestazioni, il compilatore non ha bisogno di sapere nulla sulla struttura binaria del codice C ++ compilato e può lasciare quel lavoro a un linker separato. Java non utilizza un linker separato con il suo compilatore e poiché i file .class sono definiti in modo rigoroso, il compilatore è in grado di leggerli per determinare tutti i loro membri con tutti i loro tipi, senza che sia necessario ri-dichiararli in ogni unità di compilazione.

Puoi includere tutta l'implementazione in un'intestazione C ++, ma fa sì che il compilatore lo ricompili ogni volta che è #incluso, costringendo il linker a riordinare e scartare le copie duplicate.

Java promuove la separazione tra definizione della classe e implementazione, dipende solo da dove stai guardando.

Quando sei l'autore di una classe Java, puoi vedere la definizione della classe e la sua implementazione in un file. Questo semplifica il processo di sviluppo poiché devi solo andare in un posto per mantenere la classe, non devi passare tra due file (.h e .cpp come faresti in C ++). Tuttavia, quando sei il consumatore della classe hai a che fare solo con la definizione, tramite un file .class che è impacchettato in un .jar o in un .class autonomo

C ++ ti consente di separare la definizione e l'implementazione, ma è ad-hoc. Ad esempio, non c'è nulla che ti impedisca di scrivere il metodo in linea all'interno del file di intestazione e per le classi di modelli questo è obbligatorio. Il file di intestazione elenca anche tutte le variabili membro, che sono visibili a chiunque guardi il file di intestazione, anche se sono un dettaglio di implementazione della classe e irrilevante per un consumatore.