Funções e estrutura de programas em C

Uma função reúne uma tarefa para que outra parte do programa possa chamá-la. Dê a ela um nome que descreva essa tarefa e escolha suas entradas e seu resultado antes de escrever seu corpo. Em um programa C comum executado em um ambiente hospedeiro, a execução começa em main.

Crie uma definição

int square(int n)
{
    return n * n;
}

A definição tem um tipo de retorno (int), um nome (square), uma lista de parâmetros (int n) e um corpo entre chaves. O parâmetro é a variável local que recebe uma entrada. Um argumento é o valor fornecido por uma chamada: em square(6), esse valor é 6. A chamada produz 36. Defina cada função no nível do arquivo, fora de outras funções; o C padrão não permite definições de funções aninhadas.

Cada parâmetro precisa ter seu próprio tipo. Escreva int max(int a, int b), com uma vírgula separando as declarações. Em uma chamada, forneça valores sem seus tipos: max(8, 3).

Retorne um valor à função chamadora

int max(int a, int b)
{
    if (a > b)
        return a;
    return b;
}

Um return encerra imediatamente a chamada atual. Para max(8, 3), o primeiro retorno é executado, portanto o segundo nunca é alcançado. Uma expressão retornada é convertida para o tipo de retorno da função. Escolha esse tipo de modo a preservar o tipo de resultado necessário.

Para um resultado fracionário, use aritmética de ponto flutuante em todo o cálculo:

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

A chamada c_to_f(37.0) retorna 98.6. Uma versão inteira que usa c * 9 / 5 + 32 retorna 98, porque a divisão descarta a fração. Reordenar para 9 / 5 * c + 32 faz 9 / 5 ser avaliado primeiro como 1, resultando em 69 para 37. Um tipo de retorno de ponto flutuante, por si só, não pode desfazer um cálculo inteiro já realizado dentro do corpo.

Use o resultado

Uma chamada que retorna valor é uma expressão. Com a definição acima, square(3) + square(4) resulta em 25. Em square(square(2)), a chamada interna retorna 4, que se torna o argumento da chamada externa, resultando em 16. Uma instrução como square(5); é válida, mas descarta o valor retornado.

Imprimir e retornar cumprem tarefas diferentes. printf exibe texto; return fornece um resultado que a função chamadora pode armazenar ou usar em outra expressão. Se uma função comum não void alcançar sua chave de fechamento sem retornar e a função chamadora usar seu resultado, o comportamento será indefinido. Compile com -Wall -Wextra para ajudar a encontrar retornos ausentes.

Funções que não produzem valor

Uma função void executa uma tarefa sem retornar um valor. Ela pode terminar antecipadamente com return;. Por exemplo, void print_line(int width) pode imprimir uma linha de traços, mas int x = print_line(5); é inválido porque a chamada não fornece valor. Para não receber entradas, escreva void na lista de parâmetros, como em int read_sensor(void).

int main(void) retorna um código de saída ao ambiente hospedeiro. Use return 0; para indicar sucesso; <stdlib.h> também fornece EXIT_SUCCESS e EXIT_FAILURE. Alcançar o fim de main retorna zero automaticamente. Outras funções que retornam valor não têm essa exceção.

Uma chamada de função precisa de uma declaração que o compilador já tenha visto. Se a definição vier depois, coloque um protótipo antes da primeira chamada. O protótipo informa ao compilador como verificar a chamada sem fornecer o corpo da função.

Separe a declaração do corpo

#include <stdio.h>

double c_to_f(double c);

int main(void)
{
    printf("%.1f\n", c_to_f(25.0));
    return 0;
}

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

O protótipo termina com ponto e vírgula. A definição tem um corpo e não tem ponto e vírgula entre sua lista de parâmetros e a chave de abertura. Uma organização útil é: cabeçalhos, protótipos, main e depois outras definições. A saída aqui é 77.0.

Os nomes dos parâmetros são opcionais em protótipos: double c_to_f(double); declara a mesma função. Nomes como c podem documentar uma entrada, mas não precisam coincidir com os nomes da definição. Todas as declarações devem concordar quanto ao tipo de retorno e aos tipos dos parâmetros. Uma função usada precisa de uma definição; repetir protótipos compatíveis não cria mais funções.

O que o compilador verifica

Com um protótipo, o compilador verifica a quantidade de argumentos e converte cada valor fornecido para o tipo declarado do parâmetro. Dado double c_to_f(double c);, tanto c_to_f() quanto c_to_f(20.0, 5.0) têm a quantidade incorreta e exigem um diagnóstico.

Uma diferença de tipo numérico pode, por outro lado, ser uma conversão permitida:

int half(int n)
{
    return n / 2;
}

Para half(7.9), a conversão primeiro dá ao parâmetro o valor 7. A divisão inteira produz então 3. Para half(-7.9), a conversão fornece -7, e a divisão produz -3. Ambas descartam as partes fracionárias em direção a zero. A chamada não preserva o valor double original apenas porque o argumento foi escrito com um ponto decimal. Adicione -Wconversion quando quiser avisos sobre essas conversões.

Indique explicitamente quando não há parâmetros

Em C17, uma lista de parâmetros vazia em uma declaração impede a verificação completa dos argumentos; ela não autoriza argumentos arbitrários para a função definida posteriormente. Use (void) de forma consistente. O GCC 15 mudou seu dialeto C padrão para gnu23, portanto -std=c17 torna explícito o padrão pretendido ao acompanhar estes exemplos.

Corrija um problema de declaração

Chamar uma função não declarada viola o C moderno. Inclua o cabeçalho padrão que a declara, como <stdio.h> para printf, ou adicione seu próprio protótipo correspondente. As versões atuais de GCC e Clang normalmente rejeitam declarações implícitas.

Um protótipo como double area(double r); não pode corresponder a uma definição que retorna float e recebe float. Inclua o cabeçalho de um módulo no arquivo que define suas funções para que o compilador possa compará-los. Não tente corrigir uma incompatibilidade de tipos adicionando uma conversão explícita de tipo (cast) na chamada: corrija a declaração e a definição para que descrevam a mesma função.

C passa todos os argumentos por valor: cada parâmetro começa com uma cópia do valor de seu argumento. Atribuir um valor a um parâmetro inteiro comum altera essa cópia, mesmo que ele tenha o mesmo nome de uma variável da função chamadora.

Rastreie a cópia

Com <stdio.h> incluído e esta definição antes da chamada:

void double_it(int n)
{
    n *= 2;
    printf("inside: %d\n", n);
}

A função chamadora executa:

int score = 21;
double_it(score);
printf("after: %d\n", score);

A saída é inside: 42 e depois after: 21. O parâmetro muda de 21 para 42; nenhuma instrução atribui um valor à variável score da função chamadora.

Guarde um resultado retornado

int doubled(int n)
{
    return n * 2;
}

A função calcula um valor; a atribuição na função chamadora atualiza sua variável. Retornar o valor de uma variável local é seguro: int total = a + b; return total; copia o valor para fora antes que a variável local automática deixe de existir. Cálculos que usam apenas parâmetros e resultados retornados podem ser testados sem preparar um estado compartilhado oculto.

Veja por que uma troca apenas por valor falha

void swap(int a, int b)
{
    int t = a;
    a = b;
    b = t;
}

Após int p = 3, q = 7; swap(p, q);, a função chamadora ainda tem p == 3 e q == 7. O corpo trocou suas cópias. Alterar objetos da função chamadora por meio de parâmetros exige seus endereços, passados como valores de ponteiro.

Sequencie os argumentos quando a ordem for importante

Argumentos podem ser expressões como a + 1 ou square(b). Todos terminam de ser avaliados antes que o corpo da função chamada comece, mas sua ordem de avaliação não é especificada. Duas chamadas a next_ticket(), que altera o estado, em uma única impressão podem fornecer senhas em qualquer ordem. Use instruções separadas:

int first = next_ticket();
int second = next_ticket();
printf("%d %d\n", first, second);

Evite f(i, i++): sua leitura e modificação não sequenciadas de i produzem comportamento indefinido.

Uma chamada pausa a função chamadora até que um resultado esteja pronto. Rastrear as chamadas ativas explica como um programa retorna ao lugar certo e por que a recursão precisa de uma regra de parada.

Mantenha um registro por chamada ativa

A maioria das implementações usa uma pilha de chamadas. Cada chamada ativa tem um registro de ativação que guarda os valores de seus parâmetros, as variáveis locais automáticas e o ponto em que a função chamadora deve continuar. O padrão especifica o comportamento sem exigir essa organização específica da memória.

Se main chama print_table e print_table chama c_to_f, a função de conversão retorna primeiro. A execução continua dentro de print_table, que depois retorna a main. Variáveis locais automáticas comuns pertencem a uma chamada. Uma variável local estática é diferente: todas as chamadas compartilham seu único valor armazenado.

Acompanhe a descida de um cálculo recursivo

Uma função recursiva chama a si mesma para um problema menor. Um caso-base retorna diretamente; um caso recursivo avança em direção a ele.

int factorial(int n)
{
    if (n <= 1)
        return 1;
    return n * factorial(n - 1);
}

Para factorial(4), a primeira chamada não pode terminar sua multiplicação até que factorial(3) retorne. Essa chamada espera por factorial(2), que espera por factorial(1).

Há quatro chamadas ativas de fatorial no ponto mais profundo. Cada uma tem seu próprio n; chegar a n == 1 não altera os valores das chamadas anteriores.

Acompanhe a volta dos retornos

A chamada do caso-base retorna 1. A chamada com n == 2 agora calcula 2 * 1 e retorna 2. A seguinte retorna 3 * 2, ou 6; a primeira retorna 4 * 6, ou 24. Preencha os valores de retorno no rastreamento durante a volta, depois que o resultado da função chamada for conhecido.

A condição de parada deve ser alcançável para as entradas permitidas. Se o teste fosse n == 1, começar em zero continuaria a gerar chamadas com -1, -2 e valores menores em vez de alcançar um. A continuação da recursão esgota recursos e pode encerrar o programa inesperadamente. O teste mais amplo n <= 1 interrompe essas entradas, embora o fatorial matemático seja usado para inteiros não negativos.

Verifique a profundidade e o tipo do resultado

Parar corretamente não garante que o resultado caiba no tipo. Em uma plataforma com int de 32 bits, o maior valor é 2147483647. factorial(12) resulta em 479001600, que cabe; factorial(13) precisaria de 6227020800, que não cabe. O estouro de inteiro com sinal tem comportamento indefinido.

Um laço pode calcular o fatorial mantendo um produto acumulado em uma única chamada de função. A recursão é útil quando o próximo problema tem a mesma estrutura em tamanho menor. Para inteiros positivos, somar algarismos é outro exemplo: sum_digits(472) precisa de 2 + sum_digits(47), depois 2 + 7 + sum_digits(4), resultando em 13. Um rastreamento deve mostrar tanto a redução da entrada quanto a combinação posterior dos valores retornados.

Escopo é a parte do código-fonte em que um nome pode ser usado. Leia as chaves e declarações para determinar a qual variável uma expressão se refere; a ordem das chamadas não altera essas regras.

Encontre o limite do escopo

Uma variável declarada dentro de um bloco tem escopo de bloco, que começa logo após seu declarador e termina na chave de fechamento desse bloco. Parâmetros são visíveis dentro dos corpos de suas funções. Uma declaração no cabeçalho de um for, como for (int i = 0; i < 10; i++), torna i disponível durante esse laço, mas não depois dele.

Um nome declarado fora de todas as funções tem escopo de arquivo, desde sua declaração até o fim da unidade de tradução. Funções acima dessa declaração precisam de uma declaração anterior para usá-lo. O nome de um parâmetro em um protótipo tem escopo de protótipo, que termina com o protótipo. Assim, double c_to_f(double c); pode ser seguido de uma definição que chama o parâmetro de degrees.

Rastreie o sombreamento de dentro para fora

#include <stdio.h>

int x = 10;

void show(void)
{
    printf("%d\n", x);
}

int main(void)
{
    int x = 5;
    {
        int x = 1;
        printf("%d\n", x);
    }
    printf("%d\n", x);
    show();
    return 0;
}

A impressão interna usa 1, a seguinte usa 5 e show imprime 10. Prevalece a declaração visível mais próxima de x. Sair do bloco interno revela novamente a variável local externa. Chamar show não torna a variável local de main visível dentro dela: show foi definida onde o x de escopo de arquivo é visível.

Funções diferentes podem declarar, cada uma, uma variável local i, count ou result. Elas são variáveis diferentes porque suas declarações pertencem a blocos diferentes.

Declare um valor onde seus usos posteriores possam vê-lo

Este código não compila:

if (temp > 30.0) {
    int warning = 1;
}
printf("%d", warning);

A impressão está fora do escopo de warning. Se o valor precisar ser usado depois, declare-o e inicialize-o antes da condicional:

int warning = 0;
if (temp > 30.0) {
    warning = 1;
}
printf("%d", warning);

A inicialização também fornece o valor para o caminho em que a condição é falsa.

Evite criar uma nova variável por acidente

Declarar int total = 0; dentro de um laço cria uma nova variável local cada vez que se entra em seu bloco. Se você pretendia acumular em um total externo, use uma atribuição como total += value;. Ative -Wshadow para ajudar a encontrar nomes ocultados.

O escopo começa antes de o inicializador ser avaliado. Dentro de um bloco, int x = x + 1; lê o novo x, não inicializado, mesmo que exista um x externo. Use outro nome se o inicializador precisar do valor externo.

O escopo descreve onde um nome é visível no código-fonte. A duração de armazenamento descreve quanto tempo seu objeto existe durante a execução do programa. Uma variável local estática tem escopo de bloco, enquanto seu valor armazenado existe durante toda a execução.

A duração de armazenamento descreve quanto tempo o espaço de armazenamento de uma variável existe. Use variáveis automáticas para trabalho pertencente a uma chamada e armazenamento estático quando um valor precisar persistir entre chamadas.

Compare um valor novo com um valor mantido

Parâmetros e variáveis comuns de escopo de bloco têm duração de armazenamento automática. Cada chamada de função recebe suas próprias instâncias. Uma declaração sem inicializador, como int sum;, não fornece um valor inicial utilizável. Inicialize um acumulador antes de lê-lo: int sum = 0;.

Variáveis de escopo de arquivo e variáveis de escopo de bloco declaradas static têm duração de armazenamento estática. Elas existem durante toda a execução do programa. A inicialização ocorre uma vez antes do início do programa; sem um inicializador explícito, objetos numéricos começam em zero.

int next_ticket(void)
{
    static int n = 0;
    n++;
    return n;
}

Três chamadas em instruções separadas retornam 1, 2 e 3. O inicializador não é executado novamente na entrada da função. Remover static cria um novo n = 0 automático para cada chamada, portanto as três chamadas retornam 1.

O nome n continua tendo escopo de bloco. Outras funções não podem referir-se a ele diretamente pelo nome. Chamadas recursivas também compartilham a mesma variável local estática; elas não recebem cópias estáticas separadas como recebem com variáveis locais automáticas.

Inicialize uma vez, atribua quando necessário

Um inicializador numérico estático deve ser uma expressão constante em C. static int limit = 12; é válido; static int limit = read_sensor(); é inválido. Faça uma atribuição em tempo de execução no código executável quando um valor precisar vir de uma chamada. Uma instrução como n = 0; é executada sempre que a execução a alcança, portanto colocá-la no início de next_ticket reiniciaria o contador a cada chamada.

Leia os especificadores de classe de armazenamento

Compiladores modernos escolhem a alocação de registradores por conta própria, portanto escrever register raramente melhora o código. auto int x; significa o mesmo que uma variável local comum int x; em C17. C23 também permite inferência de tipo com auto x = 3.5;, que declara um double.

C17 também tem _Thread_local, escrito thread_local em C23, para armazenamento por thread. A gramática agrupa typedef com os especificadores de classe de armazenamento, embora ele dê nome a um tipo em vez de escolher o armazenamento. Em C17, normalmente apenas um especificador de classe de armazenamento aparece em uma declaração; _Thread_local também pode acompanhar static ou extern.

Um extern int count; de escopo de bloco não cria uma cópia local automática. Ele declara um objeto com ligação e duração de armazenamento estática. Sempre considere onde a declaração aparece antes de decidir o que uma palavra-chave de classe de armazenamento faz.

Uma variável global é declarada no escopo de arquivo, fora de todas as funções. Ela mantém um valor durante toda a execução e pode dar a várias funções acesso a um estado compartilhado.

Acompanhe o objeto compartilhado

#include <stdio.h>

double total_km = 0.0;

void add_trip(double km)
{
    total_km += km;
}

int main(void)
{
    add_trip(12.5);
    add_trip(7.25);
    printf("%.2f\n", total_km);
    return 0;
}

As duas chamadas atualizam o mesmo objeto, produzindo 19.75. O parâmetro km continua sendo uma cópia; a função atribui um valor separadamente a uma variável global à qual pode se referir pelo nome. A passagem por valor não impede essa atribuição.

Variáveis globais têm duração de armazenamento estática. Variáveis globais numéricas são inicializadas em zero por padrão e exigem inicializadores que sejam expressões constantes: int error_count; começa em 0, e double limit = 2.5 * 4; começa em 10.0.

Verifique a visibilidade e o sombreamento

Um nome global só fica visível abaixo de sua declaração. Uma função acima da definição precisa de uma declaração anterior, como extern double total_km;.

Se, em vez disso, add_trip contiver:

double total_km = 0.0;
total_km += km;

ela cria e atualiza um objeto local. A variável global permanece inalterada. Remova a declaração extra para atualizar o total compartilhado; -Wshadow ajuda a identificar ocultações acidentais.

Torne as entradas explícitas quando o compartilhamento for desnecessário

Um contador de erros compartilhado pode ser útil quando várias funções relatam falhas. Mas um cálculo que lê uma variável global tem uma entrada ausente de sua lista de parâmetros. Os testes precisam preparar esse estado, e rastrear um valor incorreto exige encontrar quem pode alterá-lo.

Uma alternativa para o cálculo das viagens é:

double with_trip(double total, double km)
{
    return total + km;
}

A função chamadora usa total = with_trip(total, 12.5);. Um teste fornece as duas entradas diretamente, sem preparar variáveis globais.

Restrinja os nomes compartilhados

Variáveis comuns de escopo de arquivo têm ligação externa. Compartilhe uma delas por meio de declarações e uma única definição; definições repetidas em arquivos diferentes quebram essa organização. Por sua vez, static no escopo de arquivo confere ligação interna, permitindo que outro arquivo tenha seu próprio objeto independente com o mesmo nome. Ambos os objetos continuam existindo durante toda a execução: aqui a palavra-chave limita a ligação, não o tempo de vida.

O pré-processador transforma o texto-fonte antes de o compilador verificar expressões e tipos de C. Suas diretivas começam com #. Examine sua saída com gcc -E file.c quando uma inclusão ou expansão de macro for difícil de explicar.

Inclua declarações e dê nomes a constantes

#include <stdio.h> insere um cabeçalho padrão. Use #include "convert.h" para um cabeçalho do projeto: o GCC procura primeiro no diretório do arquivo que faz a inclusão e depois nos caminhos de cabeçalhos configurados. A opção -Iinclude adiciona um diretório de busca. A inclusão copia o texto do cabeçalho; ela não liga funções compiladas.

Uma macro semelhante a objeto substitui tokens:

#define MAX_STUDENTS 30

Usos posteriores do token MAX_STUDENTS tornam-se 30. O pré-processador deixa a cadeia "MAX_STUDENTS" e o nome diferente MAX_STUDENTS_2 inalterados. Não escreva = nem ponto e vírgula no final. Com #define PI 3.14159;, return PI * r * r; é expandido para o código incorreto return 3.14159; * r * r;. Uma diretiva normalmente termina na quebra de linha; uma barra invertida no final faz com que ela continue.

Expanda antes de calcular

Uma macro semelhante a função não tem espaço entre seu nome e o parêntese de abertura:

#define SQUARE_BAD(x) x * x
#define SQUARE(x) ((x) * (x))

SQUARE_BAD(2 + 3) torna-se 2 + 3 * 2 + 3, que resulta em 11. 100 / SQUARE_BAD(5) torna-se 100 / 5 * 5, resultando em 100. A macro com parênteses fornece 25 e 4, respectivamente. Coloque parênteses em torno de cada parâmetro e de toda a expressão de substituição para que os operadores ao redor não alterem seu agrupamento.

Escrever #define SQUARE (x) ((x) * (x)), por outro lado, cria uma macro semelhante a objeto cuja substituição começa com (x). O espaço altera o significado da definição.

Parênteses não impedem avaliações repetidas

SQUARE(i++) é expandido para ((i++) * (i++)). Isso modifica i duas vezes sem sequenciamento, portanto o comportamento é indefinido. Uma função como square(i++) avalia o argumento uma vez antes de entrar no corpo. Prefira funções para cálculos, especialmente quando uma expressão de entrada altera o estado.

Uma macro semelhante a função não tem tipos declarados para parâmetros ou retorno. Seu código C expandido ainda é verificado quanto aos tipos, mas ela não tem um protótipo que especifique conversões de argumentos. Macros continuam úteis para proteções contra inclusão múltipla, compilação condicional e expressões constantes inteiras. Em C17, uma variável const int não é uma expressão constante inteira; uma macro ou uma constante enum pode fornecer um valor para case. C23 também introduz constexpr.

Transforme argumentos em tokens ou texto

#define SHOW(expr) printf(#expr " = %d\n", expr)
#define CAT(a, b) a##b

SHOW(3 + 4); usa # para transformar o argumento em texto e imprime 3 + 4 = 7. CAT(temp, 1) usa ## para juntar tokens no nome temp1. A conversão em literal de cadeia (stringification) usa os tokens do argumento fornecido sem expandir macros nessa ocorrência; uma ocorrência comum do argumento é expandida.

Macros não seguem o escopo de bloco. Uma definição permanece ativa até #undef NAME ou o fim da unidade de tradução, mesmo que a diretiva tenha sido escrita entre chaves. Remova uma definição antiga com #undef antes de fornecer outro texto de substituição.

A compilação condicional seleciona quais linhas do código-fonte chegam ao compilador. Ela pode ativar saída de depuração, escolher código de uma plataforma ou proteger um cabeçalho contra inclusão repetida.

Teste a existência ou teste um valor

#define DEBUG 0

#ifdef DEBUG
/* Kept: DEBUG exists. */
#endif

#if DEBUG
/* Removed: DEBUG expands to zero. */
#endif

#ifdef DEBUG verifica se a macro está definida. #if DEBUG avalia seu valor de substituição como uma expressão constante inteira. Dentro de #if, um identificador não definido conta como zero; uma macro escrita incorretamente pode remover um ramo silenciosamente. As expressões defined DEBUG e defined(DEBUG) testam a existência.

Use #ifndef NAME para o teste oposto de existência. Feche cada condicional com #endif. #elif acrescenta outra condição e #else fornece a alternativa final. C23 acrescenta #elifdef e #elifndef; C17 pode expressar esses testes usando #elif defined(NAME) ou #elif !defined(NAME).

Escolha a configuração em tempo de compilação

#ifdef DEBUG
printf("debug: c = %.1f\n", c);
#endif

gcc -std=c17 -DDEBUG main.c define DEBUG como 1 e mantém a impressão. Sem essa definição, a linha é removida antes da compilação. -DLEVEL=2 fornece um valor como se #define LEVEL 2 aparecesse antes do texto do arquivo.

Isso é diferente de um if comum, cuja condição é avaliada durante a execução do programa. Condições do pré-processador não podem ler uma variável comum de tempo de execução. #if 0 remove um bloco, inclusive código com comentários /* */ existentes que tornariam inseguro envolvê-lo em outro comentário desse tipo.

Proteja um cabeçalho

#ifndef CONVERT_H
#define CONVERT_H

double c_to_f(double c);

#endif

A primeira inclusão define CONVERT_H e mantém o protótipo. Inclusões posteriores na mesma unidade de tradução ignoram o conteúdo. Use um nome de proteção distinto baseado no nome do cabeçalho; evite sublinhados iniciais reservados à implementação. Outra unidade de tradução inicia seu próprio pré-processamento e inclui as declarações para si. Uma proteção não impede que arquivos-objeto diferentes definam o mesmo símbolo externo.

Muitos compiladores aceitam #pragma once, mas ela não é uma diretiva ISO C. Proteções funcionam com diretivas condicionais padrão.

Leia as informações predefinidas

Os valores de versão incluem 199901L para C99, 201112L para C11, 201710L para C17 e 202311L para C23. __func__ contém o nome da função atual, mas é um identificador predefinido, não uma macro.

Um ramo específico de plataforma pode testar defined(_WIN32) ou defined(__linux__) e depois usar #else como alternativa. Para rejeitar explicitamente uma compilação não aceita, escreva uma condição seguida de #error "This program needs C11 or later" e #endif. A omissão de #endif, por outro lado, produz um erro de diretiva como “unterminated conditional directive”.

A compilação separada transforma cada arquivo-fonte em um arquivo-objeto antes de ligar o programa. Isso permite reutilizar arquivos-objeto inalterados e dá às funções relacionadas um lugar bem definido.

Acompanhe as etapas de compilação

Uma unidade de tradução é um arquivo .c após o pré-processamento, incluindo o conteúdo dos cabeçalhos incluídos. Cada unidade é compilada independentemente.

Um arquivo-objeto contém código de máquina e informações sobre os símbolos que define ou dos quais precisa. Em sistemas do tipo Unix, geralmente tem o sufixo .o. O ligador conecta usos de nomes externos a definições fornecidas por arquivos-objeto e bibliotecas.

Compile dois arquivos e ligue-os

Suponha que convert.h declare double c_to_f(double c);, que convert.c inclua esse cabeçalho e defina a função e que main.c inclua o cabeçalho e a chame.

gcc -Wall -Wextra -std=c17 -c main.c
gcc -Wall -Wextra -std=c17 -c convert.c
gcc main.o convert.o -o temp

O primeiro comando produz main.o sem fazer a ligação. O segundo produz convert.o. O último cria o executável temp a partir dos dois arquivos-objeto. Você também pode compilar e ligar em um único comando:

gcc -Wall -Wextra -std=c17 main.c convert.c -o temp

Forneça os arquivos-fonte para compilação e os arquivos-objeto para ligação. Cabeçalhos entram por meio de #include; não os liste como fontes do programa compiladas separadamente. Se apenas convert.c mudar, reutilize main.o, gere novamente convert.o e faça a ligação outra vez. Se um cabeçalho compartilhado mudar, gere novamente cada arquivo-objeto cujo arquivo-fonte o inclua.

Diagnostique a etapa que falhou

Um erro de compilação diz respeito a uma unidade de tradução: sintaxe inválida, quantidade incorreta de argumentos ou tipos visíveis conflitantes. O ligador não pode corrigi-los.

Um erro de ligação diz respeito ao programa montado. Se você compilar apenas main.c, o protótipo pode permitir que a compilação seja bem-sucedida, enquanto a ligação informa “undefined reference to c_to_f” ou “Undefined symbols”. A declaração informa a existência de uma função; ela não fornece seu código de máquina. Adicione convert.c a uma compilação combinada ou convert.o à ligação.

Duas definições externas ligadas da mesma função causam um erro de símbolo duplicado. Um programa comum tem uma main; ligar dois arquivos-fonte que a definem falha. Funções static privadas ao arquivo podem ter nomes iguais em unidades de tradução diferentes porque têm ligação interna.

Bibliotecas também fornecem definições. Em muitos sistemas Linux, código que usa funções declaradas por <math.h> precisa de uma opção de ligação da biblioteca matemática: gcc main.c -o app -lm. Mantenha essa opção de biblioteca depois do código que precisa dela.

Inclua a interface, compile a implementação

Evite #include "convert.c". Isso copia corpos de funções para outra unidade de tradução. Se convert.c também for compilado e ligado, suas definições externas aparecerão duas vezes. O arquivo .h de um módulo compartilha suas declarações; seu arquivo .c é compilado uma vez como arquivo-fonte.

O cabeçalho de um módulo compartilha sua interface; seu arquivo-fonte fornece a implementação. Tanto as funções chamadoras quanto a implementação incluem o cabeçalho para que suas declarações sejam compatíveis.

Declare a interface uma vez

Um convert.h com proteção contra inclusão múltipla contém:

#ifndef CONVERT_H
#define CONVERT_H

double c_to_f(double c);
double f_to_c(double f);

#endif

A implementação em convert.c o inclui antes dos corpos:

#include "convert.h"

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

double f_to_c(double f)
{
    return (f - 32.0) * 5.0 / 9.0;
}

Uma função chamadora inclui o mesmo cabeçalho e <stdio.h>. A chamada printf("%.1f %.1f\n", c_to_f(25.0), f_to_c(212.0)); imprime 77.0 100.0.

Se a implementação definir float c_to_f(float c), incluir seu cabeçalho expõe os tipos conflitantes ao compilador. A compilação independente sem essa declaração pode não detectar a incompatibilidade.

Escolha o conteúdo correto

Um cabeçalho que contém int count = 0; define um objeto em cada unidade de tradução que o inclui, causando definições externas duplicadas. Mesmo int count; é uma definição tentativa. A configuração padrão do GCC desde a versão 10 diagnostica cópias repetidas no momento da ligação, enquanto algumas ferramentas mesclam símbolos comuns e ocultam o defeito. Use extern int count; no cabeçalho e uma definição em um arquivo-fonte.

Torne a inclusão confiável

Uma proteção impede o processamento repetido dentro de uma unidade de tradução, inclusive a inclusão indireta por meio de outros cabeçalhos. Protótipos compatíveis podem se repetir, mas definições de tipos como um enum podem causar erros de redefinição.

Um cabeçalho autossuficiente inclui o que suas declarações precisam. Se um protótipo usa size_t, inclua <stddef.h> nele. As funções chamadoras não devem precisar de uma ordem especial de inclusão.

Para cabeçalhos do projeto, as aspas fazem o GCC procurar primeiro no diretório do arquivo que faz a inclusão. Adicione um diretório separado de cabeçalhos com -Iinclude, como em gcc -Iinclude -std=c17 -c src/main.c. O arquivo-objeto da implementação ainda precisa ser ligado.

A ligação determina se declarações em lugares diferentes se referem à mesma entidade. Ela é separada do escopo, que descreve onde um nome pode ser usado, e da duração de armazenamento, que descreve quanto tempo um objeto existe.

Conecte um nome a um objeto

Funções e variáveis comuns de escopo de arquivo têm ligação externa por padrão. static no escopo de arquivo confere ligação interna. Variáveis locais automáticas comuns e parâmetros não têm ligação.

Para compartilhar um contador de erros, coloque estas declarações em um cabeçalho com proteção contra inclusão múltipla:

extern int error_count;
void log_error(int code);

Um arquivo-fonte inclui esse cabeçalho e fornece:

int error_count = 0;

void log_error(int code)
{
    printf("error: %d\n", code);
    error_count++;
}

Esse arquivo-fonte também inclui <stdio.h> para printf. Outros arquivos-fonte incluem o cabeçalho compartilhado, não uma segunda definição. Após três chamadas, toda função chamadora que lê error_count refere-se ao mesmo objeto e vê 3.

Diferencie declaração de definição

extern int error_count; declara um objeto existente e não aloca novo armazenamento. int error_count = 0; o define. Um inicializador muda a situação: no escopo de arquivo, extern int error_count = 0; é uma definição apesar da palavra-chave. Mantenha o inicializador no único arquivo que contém a definição.

Em declarações comuns de funções públicas, extern é opcional: double c_to_f(double c); já declara uma função com ligação externa. Inclua a declaração pública no arquivo que a define para que o compilador possa verificar a compatibilidade.

Oculte o estado por trás de funções

static int count = 0;

void counter_increment(void)
{
    count++;
}

int counter_value(void)
{
    return count;
}

O valor armazenado existe durante toda a execução, mas apenas esta unidade de tradução pode referir-se a ele pelo nome count. Coloque os protótipos das funções públicas em um cabeçalho. Outro arquivo pode incrementar e ler o contador por meio dessas funções sem alterar diretamente a variável privada. Uma função auxiliar também pode ser static quando outros arquivos não precisarem dela.

Diagnostique uma escolha incorreta de ligação

Uma definição static int count; em um cabeçalho cria um contador privado independente em cada unidade de tradução que o inclui. Atualizar um não atualiza os outros. Proteções contra inclusão múltipla não mesclam esses objetos: cada unidade de tradução pré-processa sua própria cópia do cabeçalho.

Uma função definida como static em uma unidade de tradução não pode atender a uma chamada externa de outra; a ligação falha para esse nome externo. Dê ligação externa apenas às funções necessárias a outros arquivos e declare-as no cabeçalho.

Dentro de uma função, static dá a uma variável local armazenamento persistente sem ampliar seu escopo. Fora das funções, confere ligação interna a um objeto ou função. Variáveis de escopo de arquivo têm duração de armazenamento estática com ou sem essa palavra-chave.

make lê Makefile ou makefile no diretório do projeto e atualiza o alvo solicitado. Sem um argumento de alvo, normalmente gera o primeiro alvo comum.

Registre saídas e entradas

Uma regra começa com target: prerequisites. Sua receita fica nas linhas seguintes, indentadas com tabulação, ou após um ponto e vírgula na mesma linha:

CC = gcc
CFLAGS = -Wall -Wextra -std=c17 -g

temp: main.o convert.o; $(CC) $(CFLAGS) -o temp main.o convert.o

main.o: main.c convert.h; $(CC) $(CFLAGS) -c main.c

convert.o: convert.c convert.h; $(CC) $(CFLAGS) -c convert.c

.PHONY: clean
clean:; rm -f temp main.o convert.o

Aqui temp é o alvo padrão. make clean solicita a ação de limpeza. Se escrever uma receita na linha seguinte, use uma tabulação literal: espaços podem causar “missing separator”. A configuração de exibição de caracteres de espaço em branco de um editor ajuda a perceber a diferença.

Rastreie as decisões de recompilação

O make atualiza primeiro os pré-requisitos de um alvo. Em seguida, gera novamente o alvo se ele estiver ausente ou se algum pré-requisito tiver uma data de modificação mais recente.

• Primeira compilação: compilar os dois arquivos-fonte e depois ligar temp: três comandos.
• Sem alterações: nenhuma receita do programa precisa ser executada.
• Editar apenas convert.c: recompilá-lo e ligar novamente: dois comandos; reutilizar main.o.
• Editar convert.h: recompilar os dois arquivos-fonte e ligar novamente: três comandos.

O cabeçalho afeta as duas unidades de tradução, embora nenhum dos arquivos-fonte tenha sido editado. Imagine os arquivos de entrada gerando arquivos-objeto, que por sua vez geram o executável. As alterações se propagam por essas relações registradas.

Inclua dependências de cabeçalhos

A regra incompleta main.o: main.c não detecta edições em convert.h. O make não lê o código-fonte C para descobrir inclusões; ele segue os pré-requisitos declarados. Liste os cabeçalhos incluídos ou carregue arquivos de dependências gerados pelo compilador para evitar ligar arquivos-objeto desatualizados.

Mantenha juntas as operações dependentes do shell

Linhas de receita separadas normalmente usam shells separados. Uma linha que contém apenas cd build não altera o diretório da linha seguinte. Use um único comando como cd build && gcc -c ../main.c quando a compilação depender dessa mudança de diretório. Visualize as receitas planejadas com make -n.

Variáveis e regras de padrão eliminam comandos repetidos do compilador enquanto preservam o grafo de dependências. Os exemplos colocam cada receita após um ponto e vírgula na linha de sua regra. Encurte um makefile somente depois que suas relações de compilação estiverem corretas.

Dê nomes a configurações compartilhadas

CC = gcc
CFLAGS = -Wall -Wextra -std=c17 -g
OBJS = main.o convert.o

temp: $(OBJS); $(CC) $(CFLAGS) -o $@ $^

%.o: %.c convert.h; $(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

.PHONY: clean
clean:; rm -f temp $(OBJS)

$(CC) expande a variável do compilador; $(CFLAGS) expande suas opções. CPPFLAGS convencionalmente contém opções do pré-processador como -DDEBUG ou -Iinclude. As opções -Wall -Wextra ativam avisos, -g adiciona informações de depuração e -O2 ativa a otimização. Variáveis do make não definidas são expandidas para texto vazio. Escreva $(CC), não $CC: o segundo significa a variável de uma letra C, seguida de um C literal.

Leia variáveis automáticas do make dentro de uma regra

Para main.o, a parte correspondente ao padrão é main, portanto %.c torna-se main.c. A receita de compilação usa $< para passar esse arquivo-fonte ao compilador e $@ para nomear main.o. O cabeçalho é uma dependência, mas não é passado como outra entrada de compilação.

Na regra de ligação, todos os pré-requisitos são arquivos-objeto. $^ é expandido para main.o convert.o, e $@ torna-se temp. Usar $< ali passaria apenas main.o, perdendo as definições de convert.o.

O GNU make tem regras internas que podem compilar x.c em x.o usando CC, CPPFLAGS e CFLAGS. Uma regra de dependência explícita sem receita pode usar essa receita interna. O GNU make pode até gerar um programa simples com make hello a partir de hello.c sem um makefile.

Marque alvos de ação como fictícios

clean nomeia uma ação, não um arquivo a criar. .PHONY: clean garante que a ação seja executada mesmo que exista um arquivo chamado clean. rm -f não falha quando os arquivos já estão ausentes. Um alvo all que agrupa vários programas geralmente também é fictício.

Gere listas de cabeçalhos e examine as recompilações

Adicione -MMD -MP às opções de compilação para gravar um arquivo .d ao lado de cada arquivo-objeto. -MMD registra dependências de cabeçalhos do usuário; -MP adiciona regras vazias que ajudam quando um cabeçalho registrado é removido. Após o alvo padrão comum, carregue as listas com:

-include $(OBJS:.o=.d)

A substituição transforma nomes de arquivos-objeto em nomes de arquivos de dependências. O sinal de menos inicial permite que arquivos .d estejam ausentes na primeira compilação. Remova esses arquivos gerados em clean junto com os arquivos-objeto.

make -n mostra os comandos antecipadamente, make -B força a recompilação e make -j4 permite até quatro receitas de uma vez. Dependências corretas também são importantes para compilações paralelas. Alterar apenas o texto de CFLAGS não torna os arquivos-objeto existentes mais antigos que um pré-requisito. Após alterar opções, use make -B ou uma recompilação limpa para que todos os arquivos-objeto usem as novas configurações.