Test de C++: 24 preguntas, ¿qué imprime este código?

¿Cuánto C++ sabes de verdad? Estas 24 preguntas repasan las 8 lecciones de nuestro curso de C++: compilar con g++, la salida con std::print, tipos e inicialización, control y funciones, contenedores y algoritmos, clases, memoria y punteros inteligentes, plantillas, herencia y excepciones, y un proyecto con CMake. Elige una respuesta en cada pregunta y pulsa Corregir al final: verás tu nota, los aciertos por lección y la explicación de cada respuesta.

No hace falta registrarse y nada se envía a ningún sitio: el test se corrige en tu propio navegador. Todas las respuestas con código se comprobaron compilando y ejecutando el código con GCC 15.3 (C++23).

Pregunta 1Lección 1: Primeros pasos

¿Qué escribe este programa?

#include <iostream>

int main()
{
    std::cout << "Hola" << ' ' << 3 + 4 << '\n';
}

Hola 34Hola 7Hola' '7No compila: no se pueden encadenar tipos distintos con <<

Cada << envía un valor a std::cout, sea del tipo que sea. 3 + 4 se calcula antes de enviarse, porque la suma tiene más prioridad que <<, y ' ' es un carácter: un espacio. Ver la lección 1.

Pregunta 2Lección 1: Primeros pasos

¿Por qué conviene compilar siempre con -std=c++23 (o la versión que uses) en lugar de confiar en la opción por omisión?

Porque sin ella el programa sale más lentoPorque sin ella no se activan los avisosPorque es obligatorio en LinuxPorque g++ 15 y clang++ 19 compilan en C++17 si no se dice nada, y cosas como std::print no estarían disponibles

Pregunta 3Lección 1: Primeros pasos

¿Qué escribe este programa?

#include <print>

int main()
{
    std::print("a");
    std::println("b");
    std::println("c");
}

ab en una línea y c en la siguientea, b y c en tres líneasabc en una sola líneaa b c

std::print escribe sin salto de línea; std::println añade el salto al final. Por eso la «a» y la «b» quedan juntas. Ver la lección 1.

Pregunta 4Lección 2: Tipos, variables y cadenas

¿Qué pasa con este programa?

#include <print>

int main()
{
    int x{7.5};
    std::println("{}", x);
}

Escribe 7Escribe 8No compila: con llaves, C++ no permite convertir 7.5 en un int perdiendo datosEscribe 7.5

La inicialización con llaves prohíbe las conversiones con pérdida (narrowing). Con int x = 7.5; compilaría y guardaría 7 en silencio; con int x{7.5};, g++ da un error. Es una de las razones para preferir las llaves. Ver la lección 2.

Pregunta 5Lección 2: Tipos, variables y cadenas

¿Qué escribe este programa?

#include <print>

int main()
{
    int a = 7, b = 2;
    double d = a / b;
    std::println("{}", d);
}

33.543.0

a / b es una división entre dos int, que da 3 sin decimales; después ese 3 se guarda en un double. Para obtener 3.5 hay que convertir antes de dividir: static_cast<double>(a) / b. Ver la lección 2.

Pregunta 6Lección 2: Tipos, variables y cadenas

¿Qué escribe este programa?

#include <print>
#include <string>

int main()
{
    std::string s = "hola";
    s += " mundo";
    std::println("{} {}", s.size(), s[0]);
}

9 h10 hola4 h10 h

+= añade texto al final de un std::string: «hola mundo» tiene 10 caracteres, con el espacio. s[0] es el primer carácter, la «h». Ver la lección 2.

Pregunta 7Lección 3: Control y funciones

¿Qué escribe este programa?

#include <print>

void doblar(int x) { x *= 2; }
void doblar_ref(int& x) { x *= 2; }

int main()
{
    int n = 5;
    doblar(n);
    doblar_ref(n);
    std::println("{}", n);
}

51020No compila

doblar recibe una copia de n y dobla la copia, que se pierde al volver. doblar_ref recibe una referencia: trabaja sobre la propia n, que pasa de 5 a 10. Ver la lección 3.

Pregunta 8Lección 3: Control y funciones

¿Qué escribe este programa?

#include <print>

int main()
{
    int opcion = 1;
    switch (opcion) {
    case 1:
        std::print("uno ");
        [[fallthrough]];
    case 2:
        std::print("dos ");
        break;
    case 3:
        std::print("tres ");
    }
    std::println();
}

unouno dos tresuno dosNo compila: falta un break

Sin break, la ejecución «cae» al siguiente case. [[fallthrough]] le dice al compilador que es a propósito (sin él, -Wextra avisa). El break del caso 2 detiene la caída antes del 3. Ver la lección 3.

Pregunta 9Lección 3: Control y funciones

¿Qué escribe este programa?

#include <print>

int main()
{
    int c = 1;
    auto por_valor = [c] { return c; };
    auto por_referencia = [&c] { return c; };
    c = 5;
    std::println("{} {}", por_valor(), por_referencia());
}

1 15 55 11 5

[c] copia el valor de c en el momento de crear la lambda (1). [&c] guarda una referencia, así que ve el valor que tenga c al llamarla (5). Ver la lección 3.

Pregunta 10Lección 4: Contenedores y algoritmos

¿Qué escribe este programa?

#include <algorithm>
#include <print>
#include <vector>

int main()
{
    std::vector<int> v{5, 3, 8, 1};
    std::ranges::sort(v);
    v.push_back(2);
    std::println("{}", v);
}

[1, 2, 3, 5, 8][1, 3, 5, 8, 2][5, 3, 8, 1, 2][8, 5, 3, 2, 1]

std::ranges::sort ordena el vector en ese momento; el 2 se añade después con push_back, al final, y el vector no se vuelve a ordenar solo. Ver la lección 4.

Pregunta 11Lección 4: Contenedores y algoritmos

Guardas una referencia a v[0] y después haces v.push_back(x). ¿Qué puede pasar con la referencia?

Si el vector necesitaba más capacidad, movió sus elementos a otra zona de memoria y la referencia apunta a memoria liberadaNada: las referencias se actualizan solasEl push_back falla con una excepciónEl compilador no deja hacer push_back mientras haya referencias

Pregunta 12Lección 4: Contenedores y algoritmos

¿Qué escribe este programa?

#include <map>
#include <print>
#include <string>

int main()
{
    std::map<std::string, int> m;
    m["a"]++;
    if (m["b"] > 0)
        std::println("hay b");
    std::println("{}", m.size());
}

1hay b y luego 22No compila

m["a"]++ crea la clave «a» con 0 y la sube a 1. m["b"], aunque solo sea para comparar, también crea la clave «b» con valor 0: el if no se cumple, pero el map ya tiene 2 elementos. Para consultar sin insertar: find o contains. Ver la lección 4.

Pregunta 13Lección 5: Clases y objetos

¿Qué escribe este programa?

#include <print>
#include <string>

struct Traza {
    std::string nombre;
    Traza(std::string n) : nombre(n) { std::print("+{} ", nombre); }
    ~Traza() { std::print("-{} ", nombre); }
};

int main()
{
    {
        Traza a{"a"};
        Traza b{"b"};
    }
    std::println();
}

+a +b -b -a+a +b -a -b+a -a +b -b+a +b

Al cerrarse el bloque, los objetos se destruyen en orden inverso al de su creación: primero b, luego a. Es la base de RAII: los recursos se liberan solos y en el orden correcto. Ver la lección 5.

Pregunta 14Lección 5: Clases y objetos

¿Qué significa el const al final de int valor() const; en una clase?

Que el valor devuelto no se puede modificarQue el método se calcula al compilarQue el método promete no modificar el objeto, y por eso se puede llamar sobre objetos constQue el método no puede lanzar excepciones

Un método const no puede cambiar los miembros del objeto (salvo los mutable), y es el único que se puede llamar a través de una referencia const. Por eso los métodos que solo consultan deberían ser siempre const. Ver la lección 5.

Pregunta 15Lección 5: Clases y objetos

¿Qué escribe este programa?

#include <compare>
#include <print>

struct Version {
    int mayor;
    int menor;
    auto operator<=>(const Version&) const = default;
};

int main()
{
    std::println("{}", Version{1, 2} < Version{1, 10});
}

falsetrueNo compila: falta definir operator<1

operator<=> por omisión compara los miembros en el orden en que se declaran, como números: misma versión mayor (1) y 2 es menor que 10. Además, el compilador genera <, >, <= y >= a partir de él. Ver la lección 5.

Pregunta 16Lección 6: Memoria, referencias y punteros inteligentes

¿Qué escribe este programa?

#include <memory>
#include <print>
#include <utility>

int main()
{
    auto p = std::make_unique<int>(5);
    auto q = std::move(p);
    std::println("{} {}", p == nullptr, *q);
}

false 5No compila: un unique_ptr no se puede copiarEl programa falla al terminar por liberar dos vecestrue 5

Un unique_ptr no se puede copiar, pero sí mover: std::move pasa la propiedad a q y deja p vacío (nulo). Solo q liberará la memoria. Ver la lección 6.

Pregunta 17Lección 6: Memoria, referencias y punteros inteligentes

¿Qué escribe este programa?

#include <memory>
#include <print>

int main()
{
    auto a = std::make_shared<int>(1);
    {
        auto b = a;
        std::println("{}", a.use_count());
    }
    std::println("{}", a.use_count());
}

1 y 12 y 22 y 11 y 2

use_count dice cuántos shared_ptr comparten el objeto. Dentro del bloque son dos (a y b); al salir, b se destruye y queda uno. El objeto se libera cuando el contador llega a cero. Ver la lección 6.

Pregunta 18Lección 6: Memoria, referencias y punteros inteligentes

¿Qué problema tiene una función que devuelve una referencia a una de sus variables locales?

La variable se destruye al volver de la función, y la referencia queda colgando: usarla es comportamiento indefinidoNinguno, si la variable es un intQue la copia es lentaQue no compila nunca

Las variables locales viven en la pila y desaparecen al terminar la función. g++ avisa con -Wreturn-local-addr, pero no en todos los casos: devuelve por valor (la copia se elimina casi siempre) o un objeto que viva más. Ver la lección 6.

Pregunta 19Lección 7: Plantillas, herencia y errores

¿Qué escribe este programa?

#include <print>

template <typename T>
T mayor(T a, T b) { return a > b ? a : b; }

int main()
{
    std::println("{} {}", mayor(3, 7), mayor<double>(2, 2.5));
}

7 27 2.5No compila: mayor(2, 2.5) mezcla tipos3 2.5

En mayor(3, 7) el compilador deduce T = int. En la segunda llamada, con <double> se fija el tipo a mano y el 2 se convierte en 2.0; sin indicarlo, la deducción fallaría, porque 2 es int y 2.5 es double. Ver la lección 7.

Pregunta 20Lección 7: Plantillas, herencia y errores

¿Qué escribe este programa?

#include <print>
#include <string>

struct A {
    virtual ~A() = default;
    virtual std::string f() const { return "A"; }
    std::string g() const { return "A"; }
};

struct B : A {
    std::string f() const override { return "B"; }
    std::string g() const { return "B"; }
};

int main()
{
    B b;
    const A& r = b;
    std::println("{}{}", r.f(), r.g());
}

AABBABBA

f es virtual: a través de una referencia a A se llama a la versión del objeto real, B. g no es virtual: se elige por el tipo de la referencia, A, aunque el objeto sea un B. Ver la lección 7.

Pregunta 21Lección 7: Plantillas, herencia y errores

¿Qué escribe este programa?

#include <print>
#include <stdexcept>

int main()
{
    try {
        throw std::runtime_error("sin conexión");
        std::println("después del throw");
    } catch (const std::exception& e) {
        std::println("capturada: {}", e.what());
    }
}

después del throwcapturada: sin conexiónLas dos líneasNada: el programa termina con un error

throw interrumpe el bloque try en ese punto, así que la línea siguiente no se ejecuta, y salta al catch que acepta ese tipo. std::runtime_error deriva de std::exception, y what() devuelve su mensaje. Ver la lección 7.

Pregunta 22Lección 8: Un proyecto completo con CMake

En un CMakeLists.txt, ¿qué hace set(CMAKE_CXX_STANDARD 23)?

Le dice a CMake que compile con C++23, y él añade la opción correcta para cada compilador (-std=c++23 en g++)Descarga el compilador de C++23Activa todos los avisosHace que el proyecto solo funcione en Linux

CMake traduce la petición a la opción de cada compilador. Con set(CMAKE_CXX_STANDARD_REQUIRED ON), además, falla si el compilador no la soporta, en lugar de usar una versión anterior en silencio. Ver la lección 8.

Pregunta 23Lección 8: Un proyecto completo con CMake

¿Para qué sirve #pragma once al principio de un archivo de cabecera (.hpp)?

Para que la cabecera se compile una sola vez en todo el proyectoPara que se cargue más rápido en el editorPara que la cabecera sea privadaPara que, si se incluye varias veces en el mismo archivo, solo se procese la primera y no haya definiciones repetidas

Es la alternativa moderna a las guardas #ifndef/#define/#endif. No es parte del estándar, pero la entienden GCC, Clang y MSVC. Ver la lección 8.

Pregunta 24Lección 8: Un proyecto completo con CMake

¿Qué detecta la opción -fsanitize=address (AddressSanitizer) en tus pruebas?

Los errores de sintaxisTodos los fallos de seguridad del programaAccesos fuera de los límites, usos de memoria ya liberada, dobles liberaciones y fugas, en el código que se ejecutaLas condiciones de carrera entre hilos

AddressSanitizer añade comprobaciones al programa y lo detiene en el primer acceso indebido, con la línea exacta. Solo ve lo que se ejecuta, por eso se combina con buenas pruebas. Para las carreras entre hilos está ThreadSanitizer (-fsanitize=thread). Ver la lección 8.

Las preguntas siguen el orden del curso. Si fallas alguna, el enlace de su explicación te lleva a la lección donde se explica con ejemplos.