1. Il codice sorgente (file .c):
Scrivi il tuo programma C in un file con l'estensione `.c` (ad esempio,` myprogram.c`).
2. Preprocessing:
Il preprocessore (`CPP`) gestisce le direttive a partire da`#`nel tuo codice. Questo include:
* inclusi i file di intestazione: Dichiarazioni come `#include
* Espansione macro: Le macro definite usando `#define` sono sostituite con le loro definizioni.
* Compilazione condizionale: Direttive come il controllo `#ifdef` quali parti del codice sono compilate in base alle condizioni.
L'output di questa fase non è direttamente leggibile dall'uomo; È una versione modificata del tuo codice sorgente.
3. Compilation:
Il compilatore (`GCC`) traduce il codice preelaborato in linguaggio assembly, specifico per l'architettura CPU target (ad es. X86-64). Questo codice di assemblaggio rappresenta il tuo programma in una forma di basso livello che il computer può comprendere più direttamente.
4. Assemblaggio:
L'assemblatore (`as`) converte il codice di assemblaggio in codice oggetto. I file di oggetti (in genere con un'estensione `.o`, ad esempio,` myprogram.o`) contengono istruzioni per la macchina ma non sono ancora completamente eseguibili perché potrebbero dipendere da altri file di oggetti o librerie.
5. Collegamento:
Il linker (`ld`) combina il codice oggetto del programma con le librerie necessarie (come la libreria C standard,` libc`) per creare un singolo file eseguibile. Ciò comporta la risoluzione dei riferimenti tra diverse parti del codice e incorporare le funzioni della libreria richieste.
Il comando di compilazione:
Il comando tipico per compilare un programma C in CentOS usando GCC è:
`` `Bash
gcc myprogram.c -o myprogram
`` `
* `GCC`:invoca il compilatore GCC.
* `myprogram.c`:specifica il file del codice sorgente.
* `-o myprogram`:specifica il nome del file eseguibile di output. Se omesso, il nome eseguibile predefinito sarà `a.out`.
Esempio:
Diciamo che hai `myprogram.c`:
`` `c
#include
int main () {
printf ("ciao, mondo! \ n");
restituzione 0;
}
`` `
Lo compileresti e lo eseguirai in questo modo:
`` `Bash
gcc myprogram.c -o myprogram
./myprogram
`` `
Questo produrrà un file eseguibile chiamato `myprogram`, che puoi quindi eseguire dalla riga di comando. L'output sarà "ciao, mondo!".
Compilation più avanzata:
* File di origine multipla: Se il tuo programma è distribuito su più file `.c`, puoi compilarli tutti in una volta:
`` `Bash
GCC File1.c File2.c -o MyProgram
`` `
* Ottimizzazione: Flag come `-o2` (ottimizzazione di livello 2) possono migliorare le prestazioni del tuo eseguibile.
`` `Bash
gcc myprogram.c -o myprogram -o2
`` `
* Debug: Il flag `-g` aggiunge informazioni sul debug all'eseguibile, rendendo più facile l'uso di un debugger come` GDB`.
`` `Bash
gcc myprogram.c -o myprogram -g
`` `
In sintesi, la compilazione di un programma C in CentOS prevede una serie di passaggi orchestrati dalla toolchain GCC, trasformando il codice leggibile dall'uomo in un programma eseguibile con la macchina. Comprendere questi passaggi può aiutarti a diagnosticare errori di compilation e ottimizzare il processo di build.
Informazioni correlate
sistemi © www.354353.com