Funciones y estructura de programas en C

Una función agrupa una tarea para que otra parte del programa pueda llamarla. Dale un nombre que describa esa tarea y elige sus datos de entrada y su resultado antes de escribir su cuerpo. En un programa C ordinario ejecutado en un entorno anfitrión, la ejecución comienza en main.

Construir una definición

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

La definición tiene un tipo de retorno (int), un nombre (square), una lista de parámetros (int n) y un cuerpo entre llaves. El parámetro es la variable local que recibe un dato de entrada. Un argumento es el valor proporcionado por una llamada: en square(6), ese valor es 6. La llamada produce 36. Define cada función a nivel de archivo, fuera de las demás funciones; el C estándar no permite definiciones de funciones anidadas.

Cada parámetro necesita su propio tipo. Escribe int max(int a, int b), con una coma que separe las declaraciones. En una llamada, proporciona los valores sin sus tipos: max(8, 3).

Devolver un valor a la función llamadora

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

Un return termina de inmediato la llamada actual. Para max(8, 3), se ejecuta el primer retorno, por lo que nunca se llega al segundo. Una expresión devuelta se convierte al tipo de retorno de la función. Elige ese tipo para conservar la clase de resultado que necesitas.

Para obtener un resultado fraccionario, usa aritmética de coma flotante en todo el cálculo:

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

La llamada c_to_f(37.0) devuelve 98.6. Una versión entera que use c * 9 / 5 + 32 devuelve 98, porque la división descarta la fracción. Cambiar el orden a 9 / 5 * c + 32 hace que 9 / 5 se evalúe primero como 1, lo que da 69 para 37. Un tipo de retorno de coma flotante por sí solo no puede deshacer un cálculo entero ya realizado dentro del cuerpo.

Usar el resultado

Una llamada que devuelve un valor es una expresión. Con la definición anterior, square(3) + square(4) da 25. En square(square(2)), la llamada interna devuelve 4, que se convierte en el argumento de la llamada externa y da 16. Una sentencia como square(5); es válida, pero descarta el valor devuelto.

Mostrar y devolver cumplen funciones distintas. printf muestra texto; return proporciona un resultado que la función llamadora puede guardar o usar en otra expresión. Si una función ordinaria que no es void llega a su llave de cierre sin devolver un valor y la función llamadora usa su resultado, el comportamiento es indefinido. Compila con -Wall -Wextra para ayudar a detectar retornos ausentes.

Funciones que no producen un valor

Una función void realiza una tarea sin devolver un valor. Puede salir antes con return;. Por ejemplo, void print_line(int width) puede mostrar una línea de guiones, pero int x = print_line(5); no es válido porque la llamada no proporciona ningún valor. Para no recibir datos de entrada, escribe void en la lista de parámetros, como en int read_sensor(void).

int main(void) devuelve un estado al entorno anfitrión. Usa return 0; para indicar éxito; <stdlib.h> también proporciona EXIT_SUCCESS y EXIT_FAILURE. Llegar al final de main devuelve cero automáticamente. Las demás funciones que devuelven valores no tienen esa excepción.

Una llamada a una función necesita una declaración que el compilador ya haya visto. Si la definición aparece más adelante, coloca un prototipo antes de la primera llamada. El prototipo indica al compilador cómo comprobar la llamada sin proporcionar el cuerpo de la función.

Separar la promesa del cuerpo

#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;
}

El prototipo termina con un punto y coma. La definición tiene un cuerpo y no lleva punto y coma entre su lista de parámetros y la llave de apertura. Una organización útil es: cabeceras, prototipos, main y después las demás definiciones. La salida aquí es 77.0.

Los nombres de los parámetros son opcionales en los prototipos: double c_to_f(double); declara la misma función. Nombres como c pueden documentar un dato de entrada, pero no tienen que coincidir con los nombres de la definición. Todas las declaraciones deben coincidir en el tipo de retorno y los tipos de los parámetros. Una función utilizada necesita una definición; repetir prototipos compatibles no crea más funciones.

Qué comprueba el compilador

Con un prototipo, el compilador comprueba el número de argumentos y convierte cada valor proporcionado al tipo declarado del parámetro. Dado double c_to_f(double c);, tanto c_to_f() como c_to_f(20.0, 5.0) tienen un número incorrecto de argumentos y requieren un diagnóstico.

En cambio, una diferencia de tipo numérico puede ser una conversión permitida:

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

Para half(7.9), la conversión da primero al parámetro el valor 7. La división entera produce entonces 3. Para half(-7.9), la conversión da -7 y la división produce -3. En ambos casos se descarta la parte fraccionaria hacia cero. La llamada no conserva el valor double original solo porque el argumento se haya escrito con un punto decimal. Añade -Wconversion cuando quieras recibir advertencias sobre estas conversiones.

Indicar explícitamente que no hay parámetros

En C17, una lista de parámetros vacía en una declaración impide la comprobación completa de los argumentos; no autoriza argumentos arbitrarios para la función que se defina finalmente. Usa (void) de forma coherente. GCC 15 cambió su dialecto de C predeterminado a gnu23, por lo que -std=c17 hace explícito el estándar previsto al seguir estos ejemplos.

Corregir un problema de declaración

Llamar a una función no declarada infringe las reglas del C moderno. Incluye la cabecera estándar que la declara, como <stdio.h> para printf, o añade tu propio prototipo compatible. Las versiones actuales de GCC y Clang normalmente rechazan las declaraciones implícitas.

Un prototipo como double area(double r); no puede coincidir con una definición que devuelve float y recibe float. Incluye la cabecera de un módulo en el archivo que define sus funciones para que el compilador pueda compararlos. No intentes corregir una discrepancia de tipos añadiendo una conversión explícita en la llamada: corrige la declaración y la definición para que describan la misma función.

C pasa todos los argumentos por valor: cada parámetro comienza con una copia del valor de su argumento. Asignar un valor a un parámetro entero ordinario cambia esa copia, incluso si comparte nombre con una variable de la función llamadora.

Seguir la copia

Con <stdio.h> incluido y esta definición antes de su llamada:

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

La función llamadora ejecuta:

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

La salida es inside: 42 y después after: 21. El parámetro cambia de 21 a 42; ninguna sentencia asigna un valor a score en la función llamadora.

Conservar un resultado devuelto

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

La función calcula un valor; la asignación de la función llamadora actualiza su variable. Devolver el valor de una variable local es seguro: int total = a + b; return total; copia el valor antes de que la variable local automática deje de existir. Los cálculos que usan solo parámetros y resultados devueltos pueden probarse sin preparar un estado compartido oculto.

Entender por qué falla un intercambio solo por valor

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

Después de int p = 3, q = 7; swap(p, q);, la función llamadora sigue teniendo p == 3 y q == 7. El cuerpo intercambió sus copias. Para modificar objetos de la función llamadora mediante parámetros se necesitan sus direcciones, pasadas como valores de puntero.

Secuenciar los argumentos cuando importa el orden

Los argumentos pueden ser expresiones como a + 1 o square(b). Todos terminan de evaluarse antes de que comience el cuerpo de la función llamada, pero su orden de evaluación no está especificado. Dos llamadas a next_ticket(), que modifica el estado, en una misma impresión pueden proporcionar los números de turno en cualquiera de los dos órdenes. Usa sentencias separadas:

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

Evita f(i, i++): su lectura y modificación no secuenciadas de i producen comportamiento indefinido.

Una llamada pausa la función llamadora hasta que hay un resultado disponible. Seguir las llamadas activas explica cómo un programa retorna al lugar correcto y por qué la recursión necesita una regla de parada.

Mantener un registro por cada llamada activa

La mayoría de las implementaciones usan una pila de llamadas. Cada llamada activa tiene un marco que registra los valores de sus parámetros, sus variables locales automáticas y dónde debe continuar la función llamadora. El estándar especifica el comportamiento sin exigir esta distribución concreta de la memoria.

Si main llama a print_table y print_table llama a c_to_f, la función de conversión retorna primero. La ejecución se reanuda dentro de print_table, que después retorna a main. Las variables locales automáticas ordinarias pertenecen a una llamada. Una variable local estática es diferente: todas las llamadas comparten su único valor almacenado.

Seguir un cálculo recursivo en la ida

Una función recursiva se llama a sí misma con un problema más pequeño. Un caso base retorna directamente; un caso recursivo avanza hacia él.

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

Para factorial(4), la primera llamada no puede terminar su multiplicación hasta que retorne factorial(3). Esa llamada espera a factorial(2), que espera a factorial(1).

En el punto más profundo hay cuatro llamadas activas a factorial. Cada una tiene su propia n; llegar a n == 1 no cambia los valores de las llamadas anteriores.

Seguir los retornos en la vuelta

La llamada del caso base devuelve 1. La llamada con n == 2 calcula ahora 2 * 1 y devuelve 2. La siguiente devuelve 3 * 2, es decir, 6; la primera devuelve 4 * 6, es decir, 24. Anota los valores de retorno en una traza durante la vuelta, después de conocer el resultado de la función llamada.

La condición de parada debe ser alcanzable para las entradas admitidas. Si la comprobación fuera n == 1, comenzar en cero seguiría produciendo llamadas con -1, -2 y valores menores en lugar de llegar a uno. Continuar la recursión agota los recursos y puede provocar un fallo. La comprobación más amplia n <= 1 detiene estas entradas, aunque el factorial matemático se usa para enteros no negativos.

Comprobar tanto la profundidad como el tipo del resultado

Detenerse correctamente no garantiza que el resultado quepa en el tipo. En una plataforma con un int de 32 bits, el valor máximo es 2147483647. factorial(12) da 479001600, que cabe; factorial(13) necesitaría 6227020800, que no cabe. El desbordamiento de enteros con signo tiene comportamiento indefinido.

Un bucle puede calcular el factorial manteniendo un producto acumulado en una sola llamada a función. La recursión es útil cuando el siguiente problema tiene la misma estructura, pero un tamaño menor. Para enteros positivos, sumar los dígitos es otro ejemplo: sum_digits(472) necesita 2 + sum_digits(47), después 2 + 7 + sum_digits(4), lo que da 13. Una traza debe mostrar tanto la reducción de la entrada como la combinación posterior de los valores devueltos.

El ámbito es la parte del código fuente donde puede usarse un nombre. Lee las llaves y las declaraciones para determinar a qué variable se refiere una expresión; el orden de las llamadas no cambia estas reglas.

Encontrar el límite del ámbito

Una variable declarada dentro de un bloque tiene ámbito de bloque, que comienza justo después de su declarador y termina en la llave de cierre de ese bloque. Los parámetros son visibles dentro de los cuerpos de sus funciones. Una declaración en la cabecera de un for, como for (int i = 0; i < 10; i++), hace que i esté disponible durante ese bucle, pero no después.

Un nombre declarado fuera de todas las funciones tiene ámbito de archivo, desde su declaración hasta el final de la unidad de traducción. Las funciones situadas antes de esa declaración necesitan una declaración previa para usarlo. El nombre de un parámetro en un prototipo tiene ámbito de prototipo, que termina con el prototipo. Así, double c_to_f(double c); puede ir seguido de una definición que llame degrees al parámetro.

Seguir la ocultación de nombres de dentro hacia fuera

#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;
}

La primera impresión, dentro del bloque interior, usa 1, la siguiente usa 5 y show muestra 10. Prevalece la declaración visible de x más cercana. Al salir del bloque interior, la variable local exterior vuelve a quedar visible. Llamar a show no hace que la variable local de main sea visible dentro de ella: show se definió donde la x de ámbito de archivo es visible.

Distintas funciones pueden declarar cada una una variable local i, count o result. Son variables distintas porque sus declaraciones pertenecen a bloques distintos.

Declarar un valor donde sea visible para sus usos posteriores

Este código no se compila:

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

La impresión está fuera del ámbito de warning. Si el valor debe usarse después, decláralo e inicialízalo antes de la condición:

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

La inicialización también proporciona el valor para la ruta en la que la condición es falsa.

Evitar una nueva variable accidental

Declarar int total = 0; dentro de un bucle crea una nueva variable local cada vez que se entra en su bloque. Si querías acumular en una total exterior, usa una asignación como total += value;. Activa -Wshadow para ayudar a detectar nombres ocultos.

El ámbito comienza antes de que se evalúe el inicializador. Dentro de un bloque, int x = x + 1; lee la nueva x sin inicializar, incluso si existe una x exterior. Usa otro nombre si el inicializador necesita el valor exterior.

El ámbito describe dónde es visible un nombre en el código fuente. La duración del almacenamiento describe cuánto tiempo existe su objeto mientras se ejecuta el programa. Una variable local estática tiene ámbito de bloque mientras su valor almacenado existe durante toda la ejecución.

La duración del almacenamiento describe cuánto tiempo existe el almacenamiento de una variable. Usa variables automáticas para el trabajo que pertenece a una llamada y almacenamiento estático cuando un valor deba sobrevivir entre llamadas.

Comparar un valor nuevo con un valor conservado

Los parámetros y las variables ordinarias de ámbito de bloque tienen duración automática del almacenamiento. Cada llamada a una función obtiene sus propias instancias. Una declaración sin inicializador, como int sum;, no proporciona un valor inicial utilizable. Inicializa un acumulador antes de leerlo: int sum = 0;.

Las variables de ámbito de archivo y las variables de ámbito de bloque declaradas static tienen duración estática del almacenamiento. Existen durante toda la ejecución del programa. La inicialización ocurre una vez antes de que el programa comience; si no hay un inicializador explícito, los objetos numéricos comienzan en cero.

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

Tres llamadas en sentencias separadas devuelven 1, 2 y 3. El inicializador no vuelve a ejecutarse al entrar en la función. Eliminar static crea una nueva variable automática n = 0 para cada llamada, por lo que las tres devuelven 1.

El nombre n sigue teniendo ámbito de bloque. Otras funciones no pueden nombrarlo directamente. Las llamadas recursivas también comparten la misma variable local estática; no reciben copias estáticas separadas como ocurre con las variables locales automáticas.

Inicializar una vez y asignar cuando sea necesario

En C, un inicializador numérico estático debe ser una expresión constante. static int limit = 12; es válido; static int limit = read_sensor(); no es válido. Realiza una asignación en tiempo de ejecución en código ejecutable cuando un valor deba proceder de una llamada. Una sentencia como n = 0; se ejecuta cada vez que la ejecución llega a ella, por lo que colocarla al principio de next_ticket restablecería el contador en cada llamada.

Interpretar los especificadores de clase de almacenamiento

Los compiladores modernos eligen por sí mismos la asignación de registros, por lo que escribir register rara vez mejora el código. auto int x; significa lo mismo que una variable local ordinaria int x; en C17. C23 también permite la inferencia de tipos con auto x = 3.5;, que declara un double.

C17 también tiene _Thread_local, escrito thread_local en C23, para el almacenamiento por hilo. La gramática agrupa typedef con los especificadores de clase de almacenamiento aunque da nombre a un tipo en lugar de elegir un almacenamiento. En C17, normalmente solo aparece un especificador de clase de almacenamiento en una declaración; _Thread_local también puede acompañar a static o extern.

Un extern int count; de ámbito de bloque no crea una copia local automática. Declara un objeto con vinculación y duración estática del almacenamiento. Ten siempre en cuenta dónde aparece la declaración antes de decidir qué hace una palabra clave de clase de almacenamiento.

Una variable global se declara en el ámbito de archivo, fuera de todas las funciones. Conserva un valor durante toda la ejecución y puede dar a varias funciones acceso a un estado compartido.

Seguir el objeto compartido

#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;
}

Ambas llamadas actualizan el mismo objeto y producen 19.75. El parámetro km sigue siendo una copia; la función asigna por separado un valor a una variable global que puede nombrar. El paso por valor no impide esa asignación.

Las variables globales tienen duración estática del almacenamiento. Las variables globales numéricas se inicializan en cero de forma predeterminada y requieren inicializadores que sean expresiones constantes: int error_count; comienza en 0 y double limit = 2.5 * 4; comienza en 10.0.

Comprobar la visibilidad y la ocultación de nombres

Un nombre global solo es visible después de su declaración. Una función situada antes de la definición necesita una declaración previa, como extern double total_km;.

Si add_trip contiene en cambio:

double total_km = 0.0;
total_km += km;

crea y actualiza un objeto local. La variable global permanece sin cambios. Elimina la declaración adicional para actualizar el total compartido; -Wshadow ayuda a identificar la ocultación accidental.

Hacer explícitos los datos de entrada cuando no es necesario compartirlos

Un contador de errores compartido puede ser útil cuando varias funciones informan de fallos. Pero un cálculo que lee una variable global tiene un dato de entrada ausente de su lista de parámetros. Las pruebas deben preparar ese estado y, para rastrear un valor incorrecto, hay que encontrar las funciones que pueden modificarlo.

Una alternativa para el cálculo de los recorridos es:

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

La función llamadora usa total = with_trip(total, 12.5);. Una prueba proporciona ambos datos de entrada directamente, sin preparar ninguna variable global.

Restringir los nombres compartidos

Las variables ordinarias de ámbito de archivo tienen vinculación externa. Comparte una mediante declaraciones y una sola definición; las definiciones repetidas en distintos archivos rompen esta organización. En cambio, static en el ámbito de archivo da vinculación interna, lo que permite que otro archivo tenga su propio objeto independiente con el mismo nombre. Ambos objetos siguen existiendo durante toda la ejecución: aquí la palabra clave limita la vinculación, no el tiempo de vida.

El preprocesador transforma el texto fuente antes de que el compilador compruebe las expresiones y los tipos de C. Sus directivas comienzan con #. Examina su salida con gcc -E file.c cuando resulte difícil explicar una inclusión o la expansión de una macro.

Incluir declaraciones y dar nombre a constantes

#include <stdio.h> inserta una cabecera estándar. Usa #include "convert.h" para una cabecera del proyecto: GCC busca primero en el directorio del archivo que la incluye y después en sus rutas de cabeceras configuradas. La opción -Iinclude añade un directorio de búsqueda. La inclusión copia el texto de la cabecera; no enlaza funciones compiladas.

Una macro de tipo objeto sustituye tokens:

#define MAX_STUDENTS 30

Los usos posteriores del token MAX_STUDENTS se convierten en 30. El preprocesador no modifica la cadena "MAX_STUDENTS" ni el nombre distinto MAX_STUDENTS_2. No escribas = ni un punto y coma al final. Con #define PI 3.14159;, return PI * r * r; se expande como el código incorrecto return 3.14159; * r * r;. Una directiva normalmente termina con el salto de línea; una barra invertida final la continúa.

Expandir antes de calcular

Una macro de tipo función no tiene espacio entre su nombre y el paréntesis de apertura:

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

SQUARE_BAD(2 + 3) se convierte en 2 + 3 * 2 + 3, que se evalúa como 11. 100 / SQUARE_BAD(5) se convierte en 100 / 5 * 5, lo que da 100. La macro agrupada da 25 y 4, respectivamente. Pon paréntesis alrededor de cada parámetro y de toda la expresión de sustitución para que los operadores que la rodean no puedan cambiar su agrupación.

Escribir en cambio #define SQUARE (x) ((x) * (x)) crea una macro de tipo objeto cuya sustitución comienza con (x). El espacio cambia el significado de la definición.

Los paréntesis no impiden la evaluación repetida

SQUARE(i++) se expande como ((i++) * (i++)). Modifica i dos veces sin secuenciación, por lo que el comportamiento es indefinido. Una función real como square(i++) evalúa el argumento una vez antes de entrar en el cuerpo. Prefiere funciones para los cálculos, especialmente cuando una expresión de entrada cambia el estado.

Una macro de tipo función no tiene tipos declarados para sus parámetros ni para su retorno. El código C expandido sigue sometiéndose a la comprobación de tipos, pero no tiene un prototipo que especifique las conversiones de argumentos. Las macros siguen siendo útiles para las guardas de inclusión, la compilación condicional y las expresiones constantes enteras. En C17, una variable const int no es una expresión constante entera; una macro o una constante enum puede proporcionar un valor para case. C23 también introduce constexpr.

Convertir argumentos en tokens o texto

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

SHOW(3 + 4); usa # para convertir el argumento en texto y muestra 3 + 4 = 7. CAT(temp, 1) usa ## para unir tokens en el nombre temp1. La conversión en literal de cadena (stringification) usa los tokens del argumento proporcionado sin expandir las macros dentro de esa aparición; una aparición ordinaria del argumento sí se expande.

Las macros no siguen el ámbito de bloque. Una definición permanece activa hasta #undef NAME o hasta el final de la unidad de traducción, incluso si la directiva se escribió entre llaves. Elimina una definición anterior con #undef antes de darle un texto de sustitución diferente.

La compilación condicional selecciona qué líneas fuente llegan al compilador. Puede activar la salida de depuración, elegir código para una plataforma o proteger una cabecera contra inclusiones repetidas.

Comprobar la existencia o comprobar un valor

#define DEBUG 0

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

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

#ifdef DEBUG pregunta si la macro está definida. #if DEBUG evalúa su valor de sustitución como una expresión constante entera. Dentro de #if, un identificador no definido cuenta como cero; una macro mal escrita puede eliminar una rama sin avisar. Las expresiones defined DEBUG y defined(DEBUG) comprueban ambas la existencia.

Usa #ifndef NAME para la comprobación opuesta de existencia. Cierra cada condicional con #endif. #elif añade otra condición y #else proporciona la alternativa. C23 añade #elifdef y #elifndef; C17 puede expresar esas comprobaciones mediante #elif defined(NAME) o #elif !defined(NAME).

Elegir la configuración en tiempo de construcción

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

gcc -std=c17 -DDEBUG main.c define DEBUG como 1 y conserva la impresión. Sin esa definición, la línea se elimina antes de la compilación. -DLEVEL=2 proporciona un valor como si #define LEVEL 2 apareciera antes del texto del archivo.

Esto difiere de un if ordinario, cuya condición se evalúa cuando se ejecuta el programa. Las condiciones del preprocesador no pueden leer una variable ordinaria de tiempo de ejecución. #if 0 elimina un bloque, incluido el código con comentarios /* */ existentes que harían inseguro rodearlo con otro comentario de ese tipo.

Proteger una cabecera

#ifndef CONVERT_H
#define CONVERT_H

double c_to_f(double c);

#endif

La primera inclusión define CONVERT_H y conserva el prototipo. Las inclusiones posteriores en esa misma unidad de traducción omiten el contenido. Usa un nombre de guarda distinto basado en el nombre de la cabecera; evita los guiones bajos iniciales reservados para la implementación. Otra unidad de traducción comienza su propio preprocesamiento e incluye las declaraciones para sí misma. Una guarda no impide que distintos archivos objeto definan el mismo símbolo externo.

Muchos compiladores admiten #pragma once, pero no es una directiva de ISO C. Las guardas funcionan con directivas condicionales estándar.

Leer la información predefinida

Los valores de versión incluyen 199901L para C99, 201112L para C11, 201710L para C17 y 202311L para C23. __func__ contiene el nombre de la función actual, pero es un identificador predefinido, no una macro.

Una rama para una plataforma puede comprobar defined(_WIN32) o defined(__linux__) y después usar #else como alternativa. Para rechazar explícitamente una construcción no admitida, escribe una condición seguida de #error "This program needs C11 or later" y #endif. En cambio, omitir un #endif produce un error de directiva como «unterminated conditional directive».

La compilación separada convierte cada archivo fuente en un archivo objeto antes de enlazar el programa. Esto permite reutilizar los archivos objeto que no han cambiado y da a las funciones relacionadas un lugar definido.

Seguir las etapas de construcción

Una unidad de traducción es un archivo .c después del preprocesamiento, incluido el contenido de las cabeceras que incluye. Cada unidad se compila de forma independiente.

Un archivo objeto contiene código máquina e información de símbolos sobre los nombres que define o necesita. En sistemas tipo Unix suele tener el sufijo .o. El enlazador conecta los usos de nombres externos con las definiciones proporcionadas por archivos objeto y bibliotecas.

Compilar dos archivos y enlazarlos

Supón que convert.h declara double c_to_f(double c);, convert.c incluye esa cabecera y define la función, y main.c incluye la cabecera y la llama.

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

El primer comando produce main.o sin enlazar. El segundo produce convert.o. El último crea el ejecutable temp a partir de ambos archivos objeto. También puedes compilar y enlazar con un solo comando:

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

Proporciona los archivos fuente para compilarlos y los archivos objeto para enlazarlos. Las cabeceras entran mediante #include; no las enumeres como archivos fuente del programa que se compilan por separado. Si solo cambia convert.c, reutiliza main.o, reconstruye convert.o y vuelve a enlazar. Si cambia una cabecera compartida, reconstruye cada archivo objeto cuyo archivo fuente la incluya.

Diagnosticar la etapa que falló

Un error de compilación afecta a una unidad de traducción: sintaxis no válida, número incorrecto de argumentos o tipos visibles incompatibles. El enlazador no puede corregirlos.

Un error de enlazado afecta al programa ensamblado. Si construyes solo main.c, el prototipo puede hacer que la compilación tenga éxito mientras que el enlazado informa «undefined reference to c_to_f» o «Undefined symbols». La declaración promete una función; no proporciona su código máquina. Añade convert.c a una construcción combinada o convert.o al enlazado.

Dos definiciones externas enlazadas de la misma función causan un error de símbolo duplicado. Un programa ordinario tiene una sola main; enlazar dos archivos fuente que la definen falla. Las funciones static privadas de un archivo pueden tener el mismo nombre en distintas unidades de traducción porque tienen vinculación interna.

Las bibliotecas también proporcionan definiciones. En muchos sistemas Linux, el código que usa funciones declaradas por <math.h> necesita una opción de enlazado de la biblioteca matemática: gcc main.c -o app -lm. Mantén esa opción de biblioteca después del código que la necesita.

Incluir la interfaz y compilar la implementación

Evita #include "convert.c". Eso copia los cuerpos de las funciones en otra unidad de traducción. Si convert.c también se compila y enlaza, sus definiciones externas aparecen dos veces. El archivo .h de un módulo comparte sus declaraciones; su archivo .c se compila una vez como archivo fuente.

La cabecera de un módulo comparte su interfaz; su archivo fuente proporciona la implementación. Tanto las funciones llamadoras como la implementación incluyen la cabecera para que sus declaraciones coincidan.

Declarar la interfaz una vez

Un archivo convert.h con guarda contiene:

#ifndef CONVERT_H
#define CONVERT_H

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

#endif

La implementación en convert.c lo incluye antes de los cuerpos:

#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;
}

Una función llamadora incluye la misma cabecera y <stdio.h>. La llamada printf("%.1f %.1f\n", c_to_f(25.0), f_to_c(212.0)); muestra 77.0 100.0.

Si la implementación define float c_to_f(float c), incluir su cabecera muestra al compilador los tipos incompatibles. La compilación independiente sin esa declaración puede pasar por alto la discrepancia.

Elegir el contenido adecuado

Una cabecera que contiene int count = 0; define un objeto en cada unidad de traducción que la incluye, lo que causa definiciones externas duplicadas. Incluso int count; es una definición tentativa. La configuración predeterminada de GCC desde la versión 10 diagnostica las copias repetidas durante el enlazado, mientras que algunas cadenas de herramientas fusionan los símbolos comunes y ocultan el defecto. Usa extern int count; en la cabecera y una sola definición en un archivo fuente.

Hacer que la inclusión sea fiable

Una guarda impide el procesamiento repetido dentro de una unidad de traducción, incluida la inclusión indirecta mediante otras cabeceras. Los prototipos compatibles pueden repetirse, pero las definiciones de tipos como un enum pueden causar errores de redefinición.

Una cabecera autosuficiente incluye lo que necesitan sus declaraciones. Si un prototipo usa size_t, incluye allí <stddef.h>. Las funciones llamadoras no deberían necesitar un orden de inclusión especial.

Para las cabeceras del proyecto, las comillas hacen que GCC busque primero en el directorio del archivo que las incluye. Añade un directorio separado de cabeceras con -Iinclude, como en gcc -Iinclude -std=c17 -c src/main.c. El archivo objeto de la implementación sigue necesitando ser enlazado.

La vinculación determina si las declaraciones en distintos lugares se refieren a la misma entidad. Es distinta del ámbito, que describe dónde puede usarse un nombre, y de la duración del almacenamiento, que describe cuánto tiempo existe un objeto.

Conectar un nombre con un objeto

Las funciones y las variables ordinarias de ámbito de archivo tienen vinculación externa de forma predeterminada. static en el ámbito de archivo da vinculación interna. Las variables locales automáticas ordinarias y los parámetros no tienen vinculación.

Para compartir un contador de errores, coloca estas declaraciones en una cabecera con guarda:

extern int error_count;
void log_error(int code);

Un archivo fuente incluye esa cabecera y proporciona:

int error_count = 0;

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

Ese archivo fuente también incluye <stdio.h> para printf. Los demás archivos fuente incluyen la cabecera compartida, no una segunda definición. Después de tres llamadas, cada función llamadora que lee error_count se refiere al mismo objeto y ve 3.

Distinguir declaración y definición

extern int error_count; declara un objeto existente y no reserva almacenamiento nuevo. int error_count = 0; lo define. Un inicializador cambia el caso: en el ámbito de archivo, extern int error_count = 0; es una definición a pesar de la palabra clave. Mantén el inicializador en el único archivo que contiene la definición.

En las declaraciones ordinarias de funciones públicas, extern es opcional: double c_to_f(double c); ya declara una función con vinculación externa. Incluye la declaración pública en el archivo que la define para que el compilador pueda comprobar su compatibilidad.

Ocultar el estado detrás de funciones

static int count = 0;

void counter_increment(void)
{
    count++;
}

int counter_value(void)
{
    return count;
}

El valor almacenado existe durante toda la ejecución, pero solo esta unidad de traducción puede referirse a él mediante el nombre count. Pon los prototipos de las funciones públicas en una cabecera. Otro archivo puede incrementar y leer el contador mediante esas funciones sin modificar directamente la variable privada. Una función auxiliar también puede ser static cuando otros archivos no la necesitan.

Diagnosticar una elección de vinculación incorrecta

Una definición static int count; en una cabecera crea un contador privado independiente en cada unidad de traducción que la incluye. Actualizar uno no actualiza los demás. Las guardas de inclusión no fusionan estos objetos: cada unidad de traducción preprocesa su propia copia de la cabecera.

Una función definida como static en una unidad de traducción no puede satisfacer una llamada externa desde otra; el enlazado falla para ese nombre externo. Da vinculación externa solo a las funciones que necesitan otros archivos y decláralas en la cabecera.

Dentro de una función, static da a una variable local almacenamiento que se conserva sin ampliar su ámbito. Fuera de las funciones, da a un objeto o función vinculación interna. Las variables de ámbito de archivo tienen duración estática del almacenamiento con o sin esa palabra clave.

make lee Makefile o makefile en el directorio del proyecto y actualiza el objetivo solicitado. Sin un argumento de objetivo, normalmente construye el primer objetivo ordinario.

Registrar salidas y entradas

Una regla comienza con target: prerequisites. Su receta está en las líneas siguientes con sangría de tabulación o después de un punto y coma en la misma línea:

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

Aquí temp es el objetivo predeterminado. make clean solicita la acción de limpieza. Si escribes una receta en la línea siguiente, usa una tabulación literal: los espacios pueden causar «missing separator». La opción del editor para mostrar los caracteres en blanco ayuda a detectar la diferencia.

Seguir las decisiones de reconstrucción

Make actualiza primero los prerrequisitos de un objetivo. Después reconstruye el objetivo si no existe o si algún prerrequisito tiene una fecha de modificación más reciente.

• Primera construcción: compilar ambos archivos fuente y después enlazar temp: tres comandos.
• Sin cambios: no es necesario ejecutar ninguna receta del programa.
• Modificar solo convert.c: recompilarlo y volver a enlazar: dos comandos; se reutiliza main.o.
• Modificar convert.h: recompilar ambos archivos fuente y volver a enlazar: tres comandos.

La cabecera afecta a ambas unidades de traducción, aunque no se haya modificado ninguno de los archivos fuente. Imagina que los archivos de entrada alimentan a los archivos objeto y que estos alimentan al ejecutable. Los cambios se propagan por esas relaciones registradas.

Incluir dependencias de cabeceras

La regla incompleta main.o: main.c no tiene en cuenta las modificaciones de convert.h. Make no lee el código fuente de C para descubrir las inclusiones; sigue los prerrequisitos declarados. Enumera las cabeceras incluidas o carga archivos de dependencias generados por el compilador para evitar enlazar archivos objeto desactualizados.

Mantener juntas las operaciones dependientes del intérprete

Las líneas separadas de una receta normalmente usan intérpretes separados. Una línea que solo contiene cd build no cambia el directorio de la línea siguiente. Usa un solo comando como cd build && gcc -c ../main.c cuando la compilación dependa de ese cambio de directorio. Previsualiza las recetas previstas con make -n.

Las variables y las reglas de patrón eliminan comandos repetidos del compilador y conservan el grafo de dependencias. Los ejemplos colocan cada receta después de un punto y coma en su línea de regla. Abrevia un archivo makefile solo después de que sus relaciones de construcción sean correctas.

Dar nombre a la configuración compartida

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 la variable del compilador; $(CFLAGS) expande sus opciones. Por convención, CPPFLAGS contiene opciones del preprocesador como -DDEBUG o -Iinclude. Las opciones -Wall -Wextra activan las advertencias, -g añade información de depuración y -O2 activa la optimización. Las variables de make no definidas se expanden como texto vacío. Escribe $(CC), no $CC: esto último significa la variable de una letra C, seguida de una C literal.

Interpretar las variables automáticas dentro de una regla

Para main.o, la raíz del patrón es main, por lo que %.c se convierte en main.c. La receta de compilación usa $< para pasar ese archivo fuente al compilador y $@ para dar nombre a main.o. La cabecera es una dependencia, pero no se pasa como otra entrada de compilación.

En la regla de enlazado, todos los prerrequisitos son archivos objeto. $^ se expande como main.o convert.o y $@ se convierte en temp. Usar $< ahí pasaría solo main.o y perdería las definiciones de convert.o.

GNU make tiene reglas predefinidas que pueden compilar x.c para obtener x.o usando CC, CPPFLAGS y CFLAGS. Una regla de dependencias explícita sin receta puede usar esa receta predefinida. GNU make incluso puede construir un programa sencillo con make hello a partir de hello.c sin un archivo makefile.

Marcar objetivos de acciones como ficticios

clean da nombre a una acción, no a un archivo que se va a crear. .PHONY: clean garantiza que la acción se ejecute incluso si existe un archivo llamado clean. rm -f tolera que los archivos ya no existan. Un objetivo all que agrupa varios programas también suele ser ficticio.

Generar listas de cabeceras y examinar reconstrucciones

Añade -MMD -MP a las opciones de compilación para escribir un archivo .d junto a cada archivo objeto. -MMD registra las dependencias de cabeceras de usuario; -MP añade reglas vacías que ayudan cuando se elimina una cabecera registrada. Después del objetivo predeterminado ordinario, carga las listas con:

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

La sustitución convierte los nombres de archivos objeto en nombres de archivos de dependencias. El signo menos inicial tolera la ausencia de archivos .d en la primera construcción. Elimina estos archivos generados en clean junto con los archivos objeto.

make -n previsualiza los comandos, make -B fuerza la reconstrucción y make -j4 permite ejecutar hasta cuatro recetas a la vez. Las dependencias correctas también importan para las construcciones paralelas. Cambiar solo el texto de CFLAGS no hace que los archivos objeto existentes sean más antiguos que un prerrequisito. Después de cambiar las opciones, usa make -B o una reconstrucción limpia para que todos los archivos objeto usen la nueva configuración.