Sintaxis de C: la estructura de un programa en C explicada

C tiene muy poca sintaxis que aprender: unas 32 palabras clave y un puñado de reglas de puntuación. Casi todos los programas que escribirás tienen la misma forma exterior, así que vale la pena desarmar esa forma una vez y con cuidado.

El programa completo más pequeño

Esto compila, se ejecuta y no hace nada:

int main(void) {
    return 0;
}

Sin includes, sin salida, sin clase ni módulo de relleno. main es el punto de entrada: cuando el sistema operativo arranca tu programa, llama a main. Cuando main retorna, el programa termina, y el valor que devuelve es el estado de salida.

Agrega salida y necesitarás un include:

#include <stdio.h>

int main(void) {
    printf("Hola, C!\n");
    return 0;
}

Directivas del preprocesador

Las líneas que empiezan con # se procesan antes de la compilación propiamente dicha, por el preprocesador. No son sentencias de C, y no llevan punto y coma.

#include <stdio.h>    /* cabecera de la biblioteca estandar - angulos */
#include "myutils.h"  /* tu propia cabecera - comillas, se busca primero al lado */
#define MAX 100       /* una macro - MAX se reemplaza por 100 en todo lo de abajo */

#include es un pegado literal de texto: el contenido entero del archivo nombrado se inserta en ese punto. stdio.h contiene la declaración de printf, que es como el compilador sabe qué argumentos recibe printf. Omite el include y obtendrás implicit declaration of function 'printf'.

La distinción entre ángulos y comillas es sobre dónde busca el compilador: <...> significa los directorios de inclusión del sistema, "..." significa buscar primero junto a este archivo.

La función main

int main(void) {
    return 0;
}

Cuatro partes, cada una con significado:

• int - el tipo de retorno de main. El valor va al sistema operativo como estado de salida, donde 0 significa éxito.
• main - el nombre reservado al que llama el entorno de ejecución. Todo programa de C alojado tiene exactamente uno.
• (void) - la lista de parámetros. void aquí significa "no recibe argumentos". Escribir main() en su lugar es legal pero más débil: los paréntesis vacíos en C significan "parámetros sin especificar", lo que desactiva la comprobación de argumentos.
• { ... } - el cuerpo de la función.

La otra forma estándar recibe argumentos de línea de comandos:

int main(int argc, char *argv[]) { ... }

Usa int main(void) hasta que los necesites.

Sentencias y puntos y coma

Una sentencia es una sola instrucción, y termina con un punto y coma.

#include <stdio.h>

int main(void) {
    int a = 5;
    int b = 7;
    int sum = a + b;
    printf("%d + %d = %d\n", a, b, sum);
    return 0;
}

Cuatro sentencias, cuatro puntos y coma. El punto y coma es un terminador, no un separador: la última sentencia de un bloque también lo necesita.

Lo que no lleva punto y coma:

#include <stdio.h>        /* linea del preprocesador - sin punto y coma */

int add(int a, int b) {   /* encabezado de una definicion de funcion - sin punto y coma */
    return a + b;
}                         /* llave de cierre de una funcion - sin punto y coma */

if (x > 0) {
    ...
}                         /* llave de cierre de un bloque de control - sin punto y coma */

El caso que muerde a todo el mundo es un punto y coma donde debería ir un cuerpo:

if (score > 90);              /* BUG: este ; es todo el cuerpo del if */
    printf("Excelente!\n");   /* siempre se ejecuta, valga lo que valga score */

Eso es C perfectamente legal. El if controla una sentencia vacía, y el printf es simplemente la siguiente línea en secuencia. -Wall avisa de ello; el compilador no te va a detener.

Bloques y llaves

Las llaves agrupan sentencias en un bloque, que cuenta como una sola sentencia allí donde se espera una sentencia.

#include <stdio.h>

int main(void) {
    int temp = 35;

    if (temp > 30) {
        printf("Hace calor.\n");
        printf("Toma agua.\n");
    }

    return 0;
}

Las llaves son opcionales cuando el cuerpo es una única sentencia, pero omitirlas es como ocurren los errores famosos: agregas una segunda línea más adelante y en silencio queda fuera del if. Usa llaves siempre.

Los bloques también crean ámbito: una variable declarada dentro de { ... } deja de existir en la llave de cierre.

#include <stdio.h>

int main(void) {
    int outer = 1;

    {
        int inner = 2;
        printf("dentro: outer=%d inner=%d\n", outer, inner);
    }

    /* inner no existe aqui */
    printf("fuera: outer=%d\n", outer);
    return 0;
}

Mayúsculas y espacios en blanco

C distingue entre mayúsculas y minúsculas en todas partes. total, Total y TOTAL son tres nombres distintos. Todas las palabras clave van en minúsculas, así que Int, Return y Printf son errores - y el mensaje de error para Printf es confuso, porque el compilador supone que te referías a alguna función de la que nunca ha oído hablar.

Los espacios en blanco, en cambio, son casi totalmente libres. El compilador trata cualquier sucesión de espacios, tabulaciones y saltos de línea como un único separador. Esto es válido:

int    main ( void )
{
    printf
    ( "Hola\n" ) ;
    return 0 ;
}

Y esto también:

int main(void){printf("Hola\n");return 0;}

Ambos compilan de forma idéntica. Como al compilador le da igual, el formato es enteramente para las personas - y la disposición convencional (una sentencia por línea, cuatro espacios o una tabulación por nivel de anidamiento, llave de apertura en la misma línea) vale la pena seguirla porque toda base de código en C que leas usará algo parecido.

Dos sitios donde los espacios en blanco sí importan: no puedes partir una palabra clave o un identificador (in t no es int), y no puedes poner un salto de línea dentro de un literal de cadena normal.

Identificadores: reglas de nombres

Un identificador es cualquier nombre que elijas: variables, funciones, tipos. Las reglas:

• Formados por letras, dígitos y guiones bajos.
• No deben empezar con un dígito. total2 está bien, 2total no.
• No pueden ser una palabra clave: nada de variables llamadas int, for o return.
• Las mayúsculas importan.
• Los nombres que empiezan con un guion bajo, y cualquiera con dos guiones bajos seguidos, están reservados para la implementación: no los inventes.

int score;        /* bien */
int total_items;  /* bien - snake_case es la convencion de C */
int _hidden;      /* legal pero reservado - evitalo */
int 2fast;        /* error */
int float;        /* error - palabra clave */

Un programa totalmente anotado

Todo lo anterior, en un solo sitio:

#include <stdio.h>          /* trae printf */

#define TAX_RATE 0.08       /* una constante de tiempo de compilacion */

/* Una definicion de funcion: tipo de retorno, nombre, parametros, cuerpo. */
double with_tax(double price) {
    return price + price * TAX_RATE;
}

int main(void) {            /* la ejecucion empieza aqui */
    double item = 25.0;     /* declaracion + inicializacion */
    double total;           /* solo declaracion */

    total = with_tax(item); /* llama a la funcion, asigna el resultado */

    /* %.2f imprime un double con dos decimales */
    printf("Articulo: %.2f\n", item);
    printf("Total:    %.2f\n", total);

    if (total > 25.0) {     /* un bloque controlado por una condicion */
        printf("Se aplico el impuesto.\n");
    }

    return 0;               /* estado de salida: exito */
}

Aquí el orden de lectura importa: with_tax se define antes de que main la use. C lee el archivo de arriba abajo, así que una función debe declararse antes de llamarla. Defínela antes, o escribe un prototipo de función arriba y defínela después.