Comprese intestazioni aggiuntive di cui non ho veramente bisogno

L'importazione in Java, C # e simili è fondamentalmente diversa dall'inclusione in C e C ++:

Il primo aggiungerà i moduli nominati a quelli considerati per la risoluzione dei simboli, quest'ultimo inserirà letteralmente il contenuto delle intestazioni nominate nell'unità di traduzione.
Ciò significa che un'intestazione può contenere tutto ciò che il file sorgente può contenere, compresi gli oggetti locali dell'unità di traduzione (potrebbero avere un costruttore e un distruttore in C ++), funzioni, strutture (e per le classi C ++).

Che non è così male come sembra per C, dato che le intestazioni tendono a contenere principalmente dichiarazioni in avanti, definizioni di struct e macro di preprocessore.

In C ++ invece, i template (che sono molto più potenti dei generici Java o C # di gran lunga più potenti) devono generalmente essere implementati nelle intestazioni, il che li porta a dimensioni e complessità considerevoli (spesso superando per ordine di grandezza l'origine) file dell'unità di traduzione).

Il comitato C ++ sta lavorando su un sistema modulare per occuparsene, ma al più presto ci sarà in C ++ 17 (e non trattenere ancora il respiro).

Quindi, per le lingue con modulo-sistema (Java, C #) si avrà solo un leggero rallentamento per l'analisi e la compilazione.
Per C, probabilmente avrai solo un rallentamento leggermente più alto, dovuto all'inclusione letterale della fonte, anche se almeno tendono a non essere troppo grandi e complessi.
Per C ++, si verificherà un rallentamento da moderato a grave della compilazione e dell'analisi, a causa dell'uso intensivo di modelli e funzioni inline.

In entrambe le intestazioni C e C ++, in teoria, possono contenere oggetti locali TU, il che comporterebbe un sovraccarico di runtime.
Mentre so che tale è usato da C ++ per <iostream> (cerca ios_base::Init nello standard) per inizializzare i flussi C ++ abbastanza presto, non so di alcun uso in C.

Se non si utilizzano intestazioni precompilate, ciascuna include significa che l'intestazione è inclusa completamente in ciascuna unità di compilazione. Ciò significa leggere il file e inserirlo nella stessa pipeline del resto del codice e riempire la tabella dei simboli.

Quindi yeah inutilizzato include rallenterà la compilazione.

Alcuni compilatori avranno ottimizzazioni sul posto che alleggeriscono la maggior parte del lavoro di analisi creando intestazioni precompilate che hanno solo simboli e modelli in un formato proprietario facile da analizzare. Tuttavia, effettuando la ricerca ogni #include richiederà ancora del tempo.

Le importazioni di Java sono leggermente diverse, quando si importa un pacchetto (ad esempio import java.util.* ) il compilatore guarderà attraverso la directory / jar specificata nel percorso della classe e creerà una mappa delle classi public in modo tale ArrayList viene tradotto in java.util.ArrayList . Allo stesso modo per l'importazione di una classe; viene rilevato e aggiunto alla tabella di traduzione. Fare un static import richiede di cercare nel file di classe e di analizzare le dichiarazioni pubbliche al suo interno.

Un altro svantaggio in C / ++ per includere un'intestazione non necessaria in un file sorgente: se le intestazioni precompilate non vengono utilizzate, la modifica del file di intestazione non necessario impone la ricompilazione di tale file sorgente.