Funciones, scope y storage classes

Las funciones organizan el código, pero en C hay matices que definen tu dominio del lenguaje: todo se pasa por valor, las clases de almacenamiento controlan visibilidad y duración, e inline y los atributos afinan el comportamiento. Aquí se construye la base de la modularidad.

Declaración, definición y paso por valor

Una declaración (prototipo) dice que la función existe; la definición la implementa:

int cuadrado(int x);          // declaración (suele ir en un .h)

int cuadrado(int x) {         // definición
    return x * x;
}

Regla fundamental: C pasa todo por valor. La función recibe una copia del argumento; modificarla no afecta al original:

void incrementar(int n) { n++; }     // no cambia nada fuera
int a = 5;
incrementar(a);                       // a sigue siendo 5

Scope y clases de almacenamiento

Dónde vive una variable y cuánto dura lo controlan las storage classes:

int contador(void) {
    static int n = 0;    // se inicializa una vez; persiste entre llamadas
    return ++n;          // 1, 2, 3, … en llamadas sucesivas
}

static int oculto = 42;  // solo visible en ESTE archivo (linkage interno)
extern int global;       // definido en OTRO archivo

inline

inline sugiere al compilador que incruste el cuerpo de la función en el sitio de la llamada, evitando el coste de llamar. Es una sugerencia, no una orden:

inline int max(int a, int b) { return a > b ? a : b; }

En la práctica, con -O2 el compilador ya decide qué incrustar mejor que tú. Usa inline sobre todo para funciones pequeñas en headers (evita errores de definición múltiple), no como técnica de optimización manual.

Atributos de C23

C23 estandariza atributos [[...]] que ayudan al compilador a avisarte:

[[nodiscard]] int abrir(const char *ruta);  // avisa si ignoras el retorno
void usar([[maybe_unused]] int x);           // silencia "no usado" a propósito
[[noreturn]] void abortar(void);             // esta función no vuelve
[[deprecated("usa nueva_api")]] void vieja(void);

[[nodiscard]] es especialmente valioso: si una función devuelve un código de error o un recurso que hay que liberar, marca su retorno para que el compilador te avise cuando lo ignores por descuido.