Sintaxis de C++: sentencias, punto y coma, llaves y main()

De "compila" a "puedo leerlo"

En la página anterior tomaste un archivo de código fuente y lo convertiste en un programa en ejecución con un compilador. Ahora vamos a ir más despacio y observar qué había realmente en ese archivo. Todo programa de C++ está construido a partir del mismo puñado de piezas estructurales, y una vez que sepas nombrarlas, un archivo .cpp desconocido deja de parecer ruido.

Aquí tienes un programa completo y ejecutable. Léelo una vez y luego lo desmontaremos línea por línea.

#include <iostream>
using namespace std;

int main() {
    cout << "Hello, C++!" << endl;
    return 0;
}

Cinco líneas con contenido, y cada una de ellas cumple una función específica. Vamos a recorrerlas.

La línea #include

#include <iostream>

Esta línea incorpora el encabezado <iostream> para que puedas usar funciones de entrada/salida como cout. El #include es una directiva de preprocesador: se ejecuta antes de la compilación real y, en esencia, pega el contenido de ese encabezado en tu archivo.

Dos cosas hacen especiales a las líneas #include:

• Empiezan con #, que las marca como directivas de preprocesador.
• No terminan con punto y coma. Esta es la excepción común al hábito de "toda línea termina en ;" que estás a punto de adquirir.

Si usas cout pero olvidas #include <iostream>, el compilador no sabrá qué es cout y obtendrás un error como 'cout' was not declared in this scope. La solución casi siempre es un include que falta.

La función main

int main() {
    // ...
    return 0;
}

main es donde empieza tu programa. Cuando ejecutas el programa compilado, la ejecución comienza en la primera línea dentro de main y se detiene cuando main retorna. Todo programa de C++ tiene exactamente un main: ni más, ni menos.

Las piezas:

• int - main devuelve un entero al sistema operativo. Por convención, 0 significa "terminó con éxito".
• main() - el nombre, seguido de paréntesis para sus parámetros (vacíos aquí).
• { ... } - las llaves envuelven el cuerpo: las sentencias que se ejecutan.
• return 0; - termina main e informa de éxito. Si lo omites, C++ trata main como si hubiera devuelto 0 por ti, pero escribirlo deja clara tu intención.

Sentencias y el punto y coma

Una sentencia es una instrucción completa. En C++, toda sentencia termina con un punto y coma:

#include <iostream>
using namespace std;

int main() {
    int x = 5;
    int y = 10;
    cout << x + y << endl;
    return 0;
}

C++ ignora por completo los saltos de línea y los espacios adicionales. Al compilador no le importa si pones las sentencias en una línea o en diez: el ; es lo que le indica dónde termina cada sentencia. Estas tres formas son idénticas para el compilador:

int a = 1; int b = 2;
int a = 1;
    int b = 2;
int
a
= 1;

Esa libertad viene acompañada de la trampa más común entre principiantes: un punto y coma olvidado. Mira lo que pasa aquí.

int x = 5    // <-- sin punto y coma
int y = 10;

Obtendrás un error como expected ';' before 'int'. Fíjate en el detalle: el compilador solo se da cuenta de que algo está mal cuando llega a la línea siguiente, así que el número de línea reportado suele apuntar una línea por debajo del error real. Cuando un error menciona que falta un ;, revisa la línea anterior a la del mensaje.

Las llaves definen bloques

Donde algunos lenguajes usan la sangría para agrupar código, C++ usa llaves { }. Todo lo que hay entre un par de llaves coincidentes es un bloque. Los cuerpos de las funciones, los bucles y las sentencias if los usan:

#include <iostream>
using namespace std;

int main() {
    int score = 85;

    if (score >= 60) {
        cout << "Pass" << endl;
        cout << "Well done" << endl;
    }

    cout << "Done checking" << endl;
    return 0;
}

Las dos líneas dentro de las llaves del if se ejecutan solo cuando la condición es verdadera. El último cout está fuera de las llaves, así que siempre se ejecuta.

Como son las llaves, y no la sangría, las que definen la estructura, C++ no te obliga a sangrar. Pero deberías hacerlo de todos modos: la sangría es la forma en que las personas leen la estructura que definen las llaves. Un error común es una llave sin pareja: cada { necesita su } de cierre. Si olvidas una, el compilador suele reportar un error cerca del final del archivo (expected '}' at end of input), lejos de donde realmente te equivocaste. Contar tus llaves, o dejar que tu editor las empareje por ti, te ahorra mucha confusión.

Salida con cout y <<

Ya has visto cout varias veces. Es el flujo de salida estándar, y le envías valores con el operador << (léelo como "mete esto en la salida"):

#include <iostream>
using namespace std;

int main() {
    cout << "Sum: " << 2 + 3 << endl;
    cout << "Next line" << "\n";
    return 0;
}

Puedes encadenar << para imprimir varias cosas seguidas. endl termina la línea (también vacía el búfer); la secuencia de escape "\n" es una manera más ligera de imprimir un salto de línea. Para programas sencillos, cualquiera de las dos sirve.

Sobre ese using namespace std; del principio: los nombres de la biblioteca estándar viven en el espacio de nombres std, así que el nombre completo es std::cout. Escribir using namespace std; una vez te permite omitir el prefijo std:: y escribir solo cout. Es cómodo en ejemplos cortos, pero en proyectos grandes muchos equipos prefieren el explícito std::cout para evitar conflictos de nombres, así que no te sorprendas de verlo escrito de cualquiera de las dos formas.

Ya puedes leer el esqueleto de cualquier programa

Includes al principio, una función main como punto de entrada, sentencias que terminan en punto y coma, llaves que agrupan código en bloques y cout << para la salida: ese esqueleto está en casi todos los archivos de C++ que abrirás. El resto del lenguaje son detalles construidos sobre estas pocas formas. Cuando un programa parezca intimidante, busca primero main y luego lee las sentencias en orden; la estructura te guiará.

Siguiente: comentarios

Ahora mismo cada línea de tus programas es código que el compilador lee. A continuación añadiremos líneas que ignora deliberadamente -los comentarios- para que puedas dejar notas para ti y para otros lectores. Verás la forma de una sola línea // y la forma de bloque /* ... */, además de cuándo es adecuada cada una.