Os programas C compilam no CENTOS (e na maioria das outras distribuições Linux) usando um compilador, normalmente GCC (GNU Compiler Collection). Aqui está um colapso do processo:
1. O código -fonte (arquivo .c): Você escreve seu programa C em um arquivo com a extensão `.c` (por exemplo,` myProgram.c`).
2. Pré -processamento: O pré -processador (`cpp`) lida com as diretivas começando com`#`no seu código. Isso inclui:
*
incluindo arquivos de cabeçalho: Declarações como `#include
` Inserir o conteúdo dos arquivos de cabeçalho da biblioteca padrão no seu código.
* Expansão de macro: As macros definidas usando `#define` são substituídas por suas definições.
* Compilação condicional: Diretivas como `#ifdef` controlam quais partes do código são compiladas com base nas condições.
A saída deste estágio não é diretamente legível pelo homem; É uma versão modificada do seu código -fonte.
3. Compilação:
O compilador (`gcc`) traduz o código pré-processado em linguagem de montagem, específica para a arquitetura da CPU de destino (por exemplo, x86-64). Este código de montagem representa seu programa em um formulário de baixo nível que o computador pode entender mais diretamente.
4. Montagem:
O assembler (`AS`) converte o código de montagem em código de objeto. Arquivos de objeto (normalmente com uma extensão `.o`, por exemplo,` myProgram.o`) contêm instruções da máquina, mas ainda não são totalmente executáveis porque podem depender de outros arquivos ou bibliotecas de objetos.
5. Linking:
O vinculador (`ld`) combina o código do objeto do seu programa com as bibliotecas necessárias (como a biblioteca C Standard C,` libc`) para criar um único arquivo executável. Isso envolve a resolução de referências entre diferentes partes do código e a incorporação das funções da biblioteca necessárias.
O comando de compilação:
O comando típico para compilar um programa C no CentOS usando o GCC é:
`` `BASH
gcc myprogram.c -o myprogram
`` `
* `gcc`:chama o compilador GCC.
* `myProgram.c`:especifica o arquivo de código -fonte.
* `-o myProgram`:especifica o nome do arquivo executável de saída. Se omitido, o nome executável padrão será `A.out`.
Exemplo:
Digamos que você tenha `myProgram.c`:
`` `c
#include
int main () {
printf ("Olá, mundo! \ n");
retornar 0;
}
`` `
Você compilaria e executaria assim:
`` `BASH
gcc myprogram.c -o myprogram
./myprogram
`` `
Isso produzirá um arquivo executável chamado "MyProgram", que você pode executar na linha de comando. A saída será "Olá, mundo!".
Compilação mais avançada:
* Múltiplos arquivos de origem: Se o seu programa estiver espalhado por vários arquivos `.c`, você poderá compilá -los de uma só vez:
`` `BASH
gcc file1.c file2.c -o myprogram
`` `
* Otimização: Sinalizadores como `-o2` (otimização de nível 2) podem melhorar o desempenho do seu executável.
`` `BASH
gcc myProgram.c -o myprogram -o2
`` `
* Depuração: O sinalizador `-g` adiciona informações de depuração ao executável, facilitando o uso de um depurador como o` gdb '.
`` `BASH
gcc myProgram.c -o myprogram -g
`` `
Em resumo, a compilação de um programa C no CentOS envolve uma série de etapas orquestradas pela Chain de ferramentas do GCC, transformando seu código legível pelo homem em um programa executável da máquina. Compreender essas etapas pode ajudá -lo a diagnosticar erros de compilação e otimizar seu processo de construção.
