Volver al blog

Ejercicios de C++ resueltos para principiantes: 10 ejercicios de menos a más (con vector, struct, clases y memoria dinámica)

Ejercicios de C++ resueltos para principiantes: 10 ejercicios de menos a más (con vector, struct, clases y memoria dinámica)

Aquí tienes diez ejercicios de C++ resueltos para principiantes, ordenados de menos a más difíciles: validar la entrada con cin, funciones, paso por referencia, string, vector con sort, matrices, struct, ficheros, una clase con operadores y memoria dinámica con new y delete. Cada uno tiene el enunciado, la solución completa, por qué está hecha así y una variación para practicar por tu cuenta.

Todo el código está compilado en C++17 sin un solo aviso con -Wall -Wextra y probado con las entradas que ves en cada ejercicio. Son los temas que más se repiten en Fundamentos de Programación, Metodología de la Programación y Programación Orientada a Objetos cuando la asignatura se da en C++, como en la Universidad de Granada o en la FIB de la UPC. Al final tienes cinco preguntas de "¿qué imprime?" con las trampas típicas de C++.

Cómo usar estos ejercicios

Leer una solución y entenderla no es lo mismo que saber escribirla. Para que te sirvan:

  1. Lee el enunciado y tápate la solución. Escribe primero los pasos en castellano, como comentarios.
  2. Intenta resolverlo al menos 15 minutos. Si te atascas, mira solo la parte donde te has atascado y sigue tú.
  3. Haz la variación. Si te sale sin mirar nada, el concepto está aprendido.

Cómo compilar. Desde la terminal, con g++ (o clang++, que acepta las mismas opciones):

g++ -std=c++17 -Wall -Wextra -g ejercicio.cpp -o ejercicio
./ejercicio
  • -std=c++17 fija la versión del lenguaje. Es la más habitual en las asignaturas. Si tu profesor pide otra, cámbiala.
  • -Wall -Wextra activan los avisos del compilador. Úsalos siempre. Detectan errores que compilan pero están mal, como escribir if (x = 0) en lugar de if (x == 0).
  • -g añade la información que necesita el depurador para ir línea a línea.

En Windows, el ejecutable es ejercicio.exe. Si no tienes compilador: en Windows, Code::Blocks lo trae incluido, y también puedes instalar MinGW-w64 con MSYS2. En Mac, xcode-select --install. En Linux, el paquete g++.

Nº Ejercicio Qué practicas
1 Calificación con la entrada validada cin, cin.fail(), clear e ignore
2 Números perfectos Funciones, bool, bucles
3 Mínimo y máximo a la vez Paso por referencia, const &
4 Cifrado César string, getline, aritmética con char
5 Media y mediana vector, push_back, sort
6 Traspuesta y matriz simétrica Matrices, pasar arrays a funciones
7 Ranking de alumnos struct, vector de struct, ordenar con criterio
8 Aprobados desde un fichero ifstream, ofstream
9 Clase Fraccion Clases, constructor, const, sobrecarga de operadores
10 Array que crece solo new[], delete[], punteros

Si vienes de C: lo que cambia en C++

En muchas carreras se aprende C primero y C++ después. Casi todo el C que sabes compila en C++, pero en clase y en el examen te pedirán hacerlo "a la manera de C++":

En C En C++
printf y scanf cout << y cin >>, sin %d ni &
char nombre[50], strcpy, strcmp string nombre, = y ==
Arrays de tamaño fijo o malloc vector<int>, que crece solo
Punteros para que una función modifique un parámetro Referencias: void f(int& x)
malloc y free new y delete, o mejor un vector
#define N 10 const int N = 10;
struct y funciones sueltas class con atributos privados y métodos
qsort con un comparador de punteros sort(v.begin(), v.end())

Si la asignatura de C todavía se te resiste, tienes cinco ejercicios de examen en C en Fundamentos de Programación en la universidad.

Ejercicio 1: calificación con la entrada validada

Enunciado. Pide una nota entre 0 y 10 (puede tener decimales) y muestra Suspenso (menos de 5), Aprobado (5 a menos de 7), Notable (7 a menos de 9) o Sobresaliente (9 o más). Si el usuario escribe algo que no es un número o está fuera de rango, vuelve a pedírsela.

#include <iostream>
#include <limits>
using namespace std;

int main() {
    double nota;
    cout << "Introduce la nota (0-10): ";

    while (!(cin >> nota) || nota < 0 || nota > 10) {
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(), '\n');
        cout << "Nota no válida. Escribe un número entre 0 y 10: ";
    }

    if (nota < 5) {
        cout << "Suspenso" << endl;
    } else if (nota < 7) {
        cout << "Aprobado" << endl;
    } else if (nota < 9) {
        cout << "Notable" << endl;
    } else {
        cout << "Sobresaliente" << endl;
    }
    return 0;
}
Introduce la nota (0-10): hola
Nota no válida. Escribe un número entre 0 y 10: 12
Nota no válida. Escribe un número entre 0 y 10: 8.75
Notable

Por qué está hecho así:

  • Si escribes "hola" cuando el programa espera un número, cin >> nota falla y cin queda bloqueado en estado de error. A partir de ahí, todas las lecturas fallan sin esperar a que escribas nada. Por eso, sin las dos líneas de dentro del bucle, el programa entra en un bucle infinito.
  • cin.clear() quita el estado de error y cin.ignore(...) tira lo que queda en esa línea (la palabra "hola"). Hacen falta las dos, y en ese orden.
  • !(cin >> nota) lee y comprueba a la vez: la lectura devuelve el propio cin, que se evalúa como false si ha fallado.
  • La trampa de la coma. cin usa el punto decimal. Si escribes 6,5, lee un 6 y deja ,5 en la entrada sin avisar. El programa diría "Aprobado" con un 6.

Variación: pide tres notas (teoría 40 %, práctica 40 %, actitud 20 %), valida cada una con este mismo bucle y muestra la calificación de la media ponderada. Si alguna parte es menor que 4, la calificación es Suspenso aunque la media pase de 5.

Ejercicio 2: números perfectos

Enunciado. Un número es perfecto si es igual a la suma de sus divisores sin contarse a sí mismo. Por ejemplo, 6 = 1 + 2 + 3. Escribe una función sumaDivisores, otra esPerfecto que la use, y muestra los números perfectos hasta un límite.

#include <iostream>
using namespace std;

int sumaDivisores(int n) {
    int suma = 0;
    for (int d = 1; d <= n / 2; d++) {
        if (n % d == 0) {
            suma += d;
        }
    }
    return suma;
}

bool esPerfecto(int n) {
    return sumaDivisores(n) == n;
}

int main() {
    int limite;
    cout << "¿Hasta qué número? ";
    cin >> limite;

    for (int i = 1; i <= limite; i++) {
        if (esPerfecto(i)) {
            cout << i << " ";
        }
    }
    cout << endl;
    return 0;
}

Con el límite en 10000 imprime 6 28 496 8128.

Por qué está hecho así:

  • Las funciones están antes de main. C++ necesita conocer una función antes de que se use. Si prefieres tenerlas debajo, declara arriba solo su cabecera (el prototipo): int sumaDivisores(int n);.
  • esPerfecto devuelve directamente la comparación. Escribir if (sumaDivisores(n) == n) return true; else return false; funciona, pero es más largo y no aporta nada.
  • Los divisores se buscan hasta n / 2, porque ningún número tiene divisores propios mayores que su mitad.
  • Cada función hace una sola cosa. Si mañana te piden los números abundantes (la suma de sus divisores es mayor que el número), reutilizas sumaDivisores sin tocarla.

Variación: escribe bool sonAmigos(int a, int b). Dos números son amigos si la suma de los divisores de cada uno es igual al otro, como 220 y 284. Muestra todas las parejas de amigos menores que 10000.

Ejercicio 3: mínimo y máximo a la vez, por referencia

Enunciado. Escribe una función que reciba un vector<int> y obtenga a la vez el mínimo y el máximo. Si el vector está vacío, tiene que indicarlo.

#include <iostream>
#include <vector>
using namespace std;

bool minMax(const vector<int>& v, int& minimo, int& maximo) {
    if (v.empty()) {
        return false;
    }
    minimo = v[0];
    maximo = v[0];
    for (int x : v) {
        if (x < minimo) minimo = x;
        if (x > maximo) maximo = x;
    }
    return true;
}

int main() {
    vector<int> temperaturas = {14, 9, 21, 17, 6, 19};
    int minimo, maximo;

    if (minMax(temperaturas, minimo, maximo)) {
        cout << "Mínima: " << minimo << endl;
        cout << "Máxima: " << maximo << endl;
    } else {
        cout << "No hay datos" << endl;
    }
    return 0;
}

Imprime Mínima: 6 y Máxima: 21.

Por qué está hecho así:

  • Una función solo puede devolver un valor con return. Para "devolver" dos, se pasan por referencia (int& minimo): la función trabaja directamente sobre las variables de main, no sobre una copia. Es lo mismo que en C harías con punteros, pero sin * ni & al llamar.
  • El vector se pasa como const vector<int>&. El & evita copiar el vector entero en cada llamada, que con un millón de elementos se nota. El const garantiza que la función no lo modifica, y el compilador da error si lo intentas.
  • El bool de retorno indica si hay resultado. Sin esa comprobación, v[0] en un vector vacío es un acceso fuera de rango: el programa puede fallar o, peor, seguir con un valor basura.
  • for (int x : v) es el for de rango: recorre todos los elementos sin manejar índices.

Variación: añade un tercer parámetro por referencia con la posición del máximo, y prueba qué pasa si quitas el & de minimo. Compila (con -Wall, con un aviso), pero main imprime un valor basura, porque su minimo nunca ha recibido nada. Entender por qué es entender el paso por valor.

Ejercicio 4: cifrado César con string

Enunciado. Pide un desplazamiento y un mensaje (con espacios) y cifra el mensaje desplazando cada letra ese número de posiciones en el alfabeto: con desplazamiento 3, la A pasa a ser D y la Z pasa a ser C. Respeta mayúsculas y minúsculas y deja igual todo lo que no sea una letra. Después, descifra el resultado para comprobar que vuelve al original.

#include <iostream>
#include <limits>
#include <string>
using namespace std;

string cifrar(const string& texto, int desplazamiento) {
    desplazamiento = (desplazamiento % 26 + 26) % 26;
    string resultado = texto;

    for (char& c : resultado) {
        if (c >= 'a' && c <= 'z') {
            c = 'a' + (c - 'a' + desplazamiento) % 26;
        } else if (c >= 'A' && c <= 'Z') {
            c = 'A' + (c - 'A' + desplazamiento) % 26;
        }
    }
    return resultado;
}

int main() {
    int desplazamiento;
    string mensaje;

    cout << "Desplazamiento: ";
    cin >> desplazamiento;
    cin.ignore(numeric_limits<streamsize>::max(), '\n');

    cout << "Mensaje: ";
    getline(cin, mensaje);

    string cifrado = cifrar(mensaje, desplazamiento);
    cout << "Cifrado:    " << cifrado << endl;
    cout << "Descifrado: " << cifrar(cifrado, -desplazamiento) << endl;
    return 0;
}
Desplazamiento: 3
Mensaje: Hola, Mundo
Cifrado:    Krod, Pxqgr
Descifrado: Hola, Mundo

Por qué está hecho así:

  • La trampa de cin y getline. cin >> desplazamiento lee el número, pero deja en la entrada el salto de línea del Enter. Sin el cin.ignore, el getline siguiente lee esa línea vacía y el mensaje queda en blanco. Es uno de los fallos más preguntados de C++.
  • getline lee la línea entera, con espacios. cin >> mensaje solo leería hasta el primer espacio: "Hola,".
  • Un char es un número pequeño. c - 'a' da la posición de la letra (0 para la a, 25 para la z), se suma el desplazamiento, % 26 hace que después de la z vuelva a empezar la a, y se suma 'a' para volver a tener una letra.
  • El resto con negativos. En C++, -1 % 26 da -1, no 25. La primera línea de cifrar convierte cualquier desplazamiento, también uno negativo, en un valor entre 0 y 25. Gracias a eso, para descifrar basta con cifrar con -desplazamiento.
  • for (char& c : resultado) usa una referencia para poder modificar cada carácter. Con char c sin &, cambiarías una copia y la cadena quedaría igual.
  • La ñ y las vocales con tilde no se cifran: en UTF-8 ocupan dos bytes y no están entre 'a' y 'z', así que se quedan tal cual.

Variación: cuenta cuántas veces aparece cada letra en un texto cifrado (un array de 26 enteros) y usa la más frecuente para adivinar el desplazamiento, sabiendo que en castellano la letra más común es la e.

Ejercicio 5: media y mediana con vector

Enunciado. Lee números hasta que el usuario escriba un 0 y muestra cuántos hay, la media, la mediana, el mínimo y el máximo. No sabes de antemano cuántos números va a escribir.

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<double> numeros;
    double x;

    cout << "Introduce números (0 para terminar): ";
    while (cin >> x && x != 0) {
        numeros.push_back(x);
    }

    if (numeros.empty()) {
        cout << "No has introducido ningún número" << endl;
        return 0;
    }

    double suma = 0;
    for (double n : numeros) {
        suma += n;
    }
    double media = suma / numeros.size();

    sort(numeros.begin(), numeros.end());

    size_t mitad = numeros.size() / 2;
    double mediana;
    if (numeros.size() % 2 == 1) {
        mediana = numeros[mitad];
    } else {
        mediana = (numeros[mitad - 1] + numeros[mitad]) / 2;
    }

    cout << "Cantidad: " << numeros.size() << endl;
    cout << "Media:    " << media << endl;
    cout << "Mediana:  " << mediana << endl;
    cout << "Mínimo:   " << numeros.front() << endl;
    cout << "Máximo:   " << numeros.back() << endl;
    return 0;
}
Introduce números (0 para terminar): 4 8 15 16 23 42 0
Cantidad: 6
Media:    18
Mediana:  15.5
Mínimo:   4
Máximo:   42

Por qué está hecho así:

  • vector crece solo con push_back. Es la respuesta de C++ a "no sé cuántos datos van a venir". Con un array tendrías que fijar un tamaño máximo y llevar la cuenta a mano.
  • La mediana es el valor del centro de los datos ordenados. Por eso se ordena antes con sort, que está en <algorithm>. Si hay un número par de datos, es la media de los dos centrales.
  • Después de ordenar, el mínimo y el máximo son el primero y el último: front() y back(). No hace falta recorrer el vector otra vez.
  • size() devuelve un size_t, un entero sin signo. Por eso mitad es size_t: mezclar int y size_t en comparaciones da avisos con -Wall -Wextra, y restar a un size_t que vale 0 da un número enorme. Lo tienes en la pregunta 5 de abajo.
  • La comprobación de empty() va antes de todo. Con el vector vacío, suma / numeros.size() dividiría entre 0 y numeros[mitad] leería fuera del vector.

Variación: calcula también la moda (el valor que más se repite). Con el vector ya ordenado, los valores iguales quedan juntos y basta un recorrido.

Ejercicio 6: traspuesta y matriz simétrica

Enunciado. Con matrices de 3 × 3, escribe una función que muestre una matriz, otra que calcule su traspuesta (cambiar filas por columnas) y otra que diga si es simétrica, es decir, si es igual a su traspuesta.

#include <iostream>
using namespace std;

const int N = 3;

void mostrar(const int m[N][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cout << m[i][j] << " ";
        }
        cout << endl;
    }
}

void traspuesta(const int m[N][N], int t[N][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            t[j][i] = m[i][j];
        }
    }
}

bool esSimetrica(const int m[N][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {
            if (m[i][j] != m[j][i]) {
                return false;
            }
        }
    }
    return true;
}

int main() {
    int a[N][N] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int b[N][N] = {
        {1, 7, 3},
        {7, 4, 5},
        {3, 5, 6}
    };
    int t[N][N];

    traspuesta(a, t);
    cout << "Traspuesta de a:" << endl;
    mostrar(t);

    cout << "¿a es simétrica? " << (esSimetrica(a) ? "sí" : "no") << endl;
    cout << "¿b es simétrica? " << (esSimetrica(b) ? "sí" : "no") << endl;
    return 0;
}
Traspuesta de a:
1 4 7
2 5 8
3 6 9
¿a es simétrica? no
¿b es simétrica? sí

Por qué está hecho así:

  • Un array no se copia al pasarlo a una función: la función recibe la dirección del original. Cualquier cambio dentro de la función cambia la matriz de main. Por eso las funciones que solo leen la reciben como const, y el compilador impide modificarla por error.
  • Una función no puede devolver un array con return. La traspuesta se devuelve rellenando un segundo array, t, que pasa main.
  • Al pasar una matriz, el compilador necesita saber cuántas columnas tiene, para calcular dónde empieza cada fila. Por eso el tamaño es una constante, N, en lugar de un número escrito a mano en cada sitio.
  • En esSimetrica, j empieza en i + 1: solo se recorre el triángulo de encima de la diagonal. Comparar también el de debajo repetiría cada comparación, y la diagonal siempre coincide consigo misma.
  • return false sale en cuanto encuentra una pareja distinta. No hace falta seguir mirando.

Variación: escribe una función que multiplique dos matrices de N × N. Es un ejercicio de examen muy habitual y obliga a tener claro qué índice recorre cada bucle.

Ejercicio 7: ranking de alumnos con struct

Enunciado. Define un struct Alumno con nombre y nota. Con una lista de alumnos, muéstralos ordenados de mayor a menor nota con un decimal, y después la media de la clase y cuántos han aprobado.

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

struct Alumno {
    string nombre;
    double nota;
};

bool mayorNota(const Alumno& a, const Alumno& b) {
    return a.nota > b.nota;
}

int main() {
    vector<Alumno> clase = {
        {"Ana", 7.5},
        {"Bruno", 4.2},
        {"Carla", 9.1},
        {"David", 5.0},
        {"Elena", 3.8}
    };

    sort(clase.begin(), clase.end(), mayorNota);

    cout << fixed << setprecision(1);
    int aprobados = 0;
    double suma = 0;

    for (const Alumno& a : clase) {
        cout << a.nombre << ": " << a.nota << endl;
        suma += a.nota;
        if (a.nota >= 5) {
            aprobados++;
        }
    }

    cout << "Media: " << setprecision(2) << suma / clase.size() << endl;
    cout << "Aprobados: " << aprobados << " de " << clase.size() << endl;
    return 0;
}
Carla: 9.1
Ana: 7.5
David: 5.0
Bruno: 4.2
Elena: 3.8
Media: 5.92
Aprobados: 3 de 5

Por qué está hecho así:

  • Un struct agrupa datos que van juntos. Es mejor que tener un vector<string> de nombres y un vector<double> de notas, porque al ordenar uno tendrías que acordarte de mover también el otro.
  • sort no sabe ordenar alumnos: no sabe si por nombre o por nota. Se le pasa una función que recibe dos alumnos y devuelve true si el primero tiene que ir antes. Con > quedan de mayor a menor.
  • La misma función se puede escribir dentro de la llamada, como lambda: sort(clase.begin(), clase.end(), [](const Alumno& a, const Alumno& b) { return a.nota > b.nota; });. Si en tu asignatura no se han visto, usa la función con nombre.
  • Sin fixed << setprecision(1), cout imprime el 5.0 de David como 5. Los dos están en <iomanip> y se mantienen para todo lo que imprimas después, hasta que los cambies. Por eso la media se imprime con setprecision(2).
  • const Alumno& a en el bucle evita copiar cada alumno (con su string) en cada vuelta.

Variación: si dos alumnos tienen la misma nota, ordénalos por nombre. Solo tienes que cambiar la función de comparación.

Ejercicio 8: aprobados desde un fichero

Enunciado. Lee el fichero notas.txt, que tiene en cada línea un nombre y una nota, y escribe en aprobados.txt solo los que tienen un 5 o más. Al final, muestra cuántos se han leído y cuántos han aprobado. Si el fichero no existe, avisa.

Ana 7.5
Bruno 4.2
Carla 9.1
David 5
Elena 3.8
#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main() {
    ifstream entrada("notas.txt");
    if (!entrada) {
        cout << "No se puede abrir notas.txt" << endl;
        return 1;
    }

    ofstream salida("aprobados.txt");
    string nombre;
    double nota;
    int leidos = 0;
    int aprobados = 0;

    while (entrada >> nombre >> nota) {
        leidos++;
        if (nota >= 5) {
            salida << nombre << " " << nota << endl;
            aprobados++;
        }
    }

    cout << "Leídos: " << leidos << ", aprobados: " << aprobados << endl;
    return 0;
}

Imprime Leídos: 5, aprobados: 3, y aprobados.txt queda con Ana, Carla y David.

Por qué está hecho así:

  • Un fichero se lee igual que cin, con >>. Y se escribe igual que en cout, con <<. Lo que cambia es que la variable es un ifstream o un ofstream, de <fstream>.
  • El bucle de lectura correcto es while (entrada >> nombre >> nota). El típico while (!entrada.eof()) procesa la última línea dos veces (con este fichero, Elena saldría repetida y "Leídos: 6"), porque eof() solo se activa después de un intento de lectura fallido. Es de los errores más comunes en las prácticas de ficheros.
  • if (!entrada) comprueba que el fichero se ha abierto. Si no lo compruebas, el bucle no lee nada y el programa dice "Leídos: 0" sin explicar por qué.
  • "No se puede abrir" aunque el fichero exista. El programa busca notas.txt en su carpeta de trabajo, que no siempre es la del .cpp. En CLion, por ejemplo, suele ser la carpeta de compilación (cmake-build-debug), y si abres el ejecutable con doble clic, es la carpeta del ejecutable. Mira qué carpeta de trabajo usa tu entorno y pon ahí el fichero.
  • No hace falta llamar a close(). Los ficheros se cierran solos cuando sus variables dejan de existir, al terminar main.

Variación: si los nombres pueden tener espacios ("Ana María"), cambia el formato a nombre;nota y lee el nombre con getline(entrada, nombre, ';') y después la nota con >>.

Ejercicio 9: clase Fraccion con operadores

Enunciado. Crea una clase Fraccion que siempre esté simplificada y con el signo en el numerador. Tiene que permitir sumar y multiplicar fracciones con + y *, mostrarlas con cout << y obtener su valor decimal. Una fracción con denominador 0 no se puede crear.

#include <cstdlib>
#include <iostream>
#include <stdexcept>
using namespace std;

int mcd(int a, int b) {
    while (b != 0) {
        int resto = a % b;
        a = b;
        b = resto;
    }
    return a;
}

class Fraccion {
private:
    int num;
    int den;

    void simplificar() {
        int divisor = mcd(abs(num), abs(den));
        num /= divisor;
        den /= divisor;
        if (den < 0) {
            num = -num;
            den = -den;
        }
    }

public:
    Fraccion(int numerador, int denominador) : num(numerador), den(denominador) {
        if (den == 0) {
            throw invalid_argument("El denominador no puede ser 0");
        }
        simplificar();
    }

    Fraccion operator+(const Fraccion& otra) const {
        return Fraccion(num * otra.den + otra.num * den, den * otra.den);
    }

    Fraccion operator*(const Fraccion& otra) const {
        return Fraccion(num * otra.num, den * otra.den);
    }

    double valor() const {
        return static_cast<double>(num) / den;
    }

    friend ostream& operator<<(ostream& os, const Fraccion& f) {
        os << f.num << "/" << f.den;
        return os;
    }
};

int main() {
    Fraccion a(1, 2);
    Fraccion b(3, 4);
    Fraccion c(6, -8);

    cout << a << " + " << b << " = " << (a + b) << endl;
    cout << a << " * " << b << " = " << (a * b) << endl;
    cout << "6/-8 simplificada: " << c << endl;
    cout << "Valor de " << b << ": " << b.valor() << endl;

    try {
        Fraccion mala(1, 0);
    } catch (const invalid_argument& e) {
        cout << "Error: " << e.what() << endl;
    }
    return 0;
}
1/2 + 3/4 = 5/4
1/2 * 3/4 = 3/8
6/-8 simplificada: -3/4
Valor de 3/4: 0.75
Error: El denominador no puede ser 0

Por qué está hecho así:

  • num y den son privados. Nadie de fuera puede poner un 0 en el denominador o dejar la fracción sin simplificar. A esa regla que la clase garantiza siempre se le llama invariante, y es la razón de ser de la encapsulación.
  • : num(numerador), den(denominador) es la lista de inicialización del constructor. Inicializa los atributos antes de entrar en las llaves. En atributos const, en referencias o en objetos sin constructor por defecto, es obligatoria.
  • El constructor lanza una excepción si el denominador es 0. Un constructor no puede devolver un código de error, así que es la forma de impedir que exista un objeto inválido.
  • Los métodos que no modifican el objeto llevan const al final (valor() const). Sin él, no podrías llamarlos sobre una fracción const, ni sobre una recibida como const Fraccion&.
  • operator+ devuelve una fracción nueva y no modifica ninguna de las dos, igual que 2 + 3 no cambia ni el 2 ni el 3. Como el resultado pasa por el constructor, sale ya simplificado.
  • operator<< no puede ser un método de la clase, porque a la izquierda del << está cout, no la fracción. Por eso es una función friend: una función de fuera de la clase con permiso para ver sus atributos privados. Devuelve el ostream para poder encadenar cout << a << " + " << b.
  • El static_cast<double> de valor() evita la división entera: 3 / 4 entre dos int da 0.

Variación: añade la resta, la división (que lanza una excepción si divides entre una fracción que vale 0) y operator==. Como las fracciones siempre están simplificadas, basta con comparar numeradores y denominadores. Si la asignatura es de POO, tienes la herencia y el polimorfismo explicados en Programación Orientada a Objetos en la universidad, con una sección específica de C++.

Ejercicio 10: array que crece solo con new y delete

Enunciado. Sin usar vector, lee enteros hasta que el usuario escriba uno negativo y muéstralos al revés. Empieza con un array dinámico de capacidad 2 y, cada vez que se llene, duplica su tamaño. Libera toda la memoria al terminar.

#include <iostream>
using namespace std;

int* ampliar(int* datos, int tam, int nuevaCapacidad) {
    int* nuevo = new int[nuevaCapacidad];
    for (int i = 0; i < tam; i++) {
        nuevo[i] = datos[i];
    }
    delete[] datos;
    return nuevo;
}

int main() {
    int capacidad = 2;
    int tam = 0;
    int* datos = new int[capacidad];

    int x;
    cout << "Introduce enteros (un negativo para terminar): ";
    while (cin >> x && x >= 0) {
        if (tam == capacidad) {
            capacidad *= 2;
            datos = ampliar(datos, tam, capacidad);
            cout << "(capacidad ampliada a " << capacidad << ")" << endl;
        }
        datos[tam] = x;
        tam++;
    }

    cout << "Al revés: ";
    for (int i = tam - 1; i >= 0; i--) {
        cout << datos[i] << " ";
    }
    cout << endl;

    delete[] datos;
    datos = nullptr;
    return 0;
}
Introduce enteros (un negativo para terminar): 3 1 4 1 5 9 -1
(capacidad ampliada a 4)
(capacidad ampliada a 8)
Al revés: 9 5 1 4 1 3

Por qué está hecho así:

  • new int[n] reserva memoria que no se libera sola. Cada new[] necesita su delete[]. Si te lo saltas, el programa funciona igual, pero esa memoria queda ocupada hasta que termina: es una fuga de memoria.
  • Lo que se reserva con new[] se libera con delete[], con corchetes. Usar delete sin corchetes con un array es comportamiento indefinido, aunque a veces parezca funcionar.
  • ampliar reserva un array más grande, copia los datos, libera el viejo y devuelve el nuevo puntero. Si no devolviera nada, main seguiría apuntando al array viejo, que ya está liberado.
  • Después del último delete[], datos se pone a nullptr. Un puntero a memoria ya liberada se llama colgante: usarlo puede funcionar, fallar o corromper otros datos. Con nullptr, un uso por error falla enseguida y es fácil de encontrar.
  • Duplicar la capacidad, en lugar de sumar 1, hace que haya muy pocas copias: para 1000 elementos, unas 10 ampliaciones en lugar de 1000. Es lo que hace vector por dentro.

En tu código del día a día, usa vector. Este ejercicio está para entender qué hace vector por ti, y porque en los exámenes de C++ sigue cayendo memoria dinámica. Si los punteros todavía te dan miedo, tienes la base con dibujos de la memoria en punteros en C explicados desde cero. Y para encontrar estos fallos en Linux o Mac, compila con -g -fsanitize=address: el programa se detiene en la línea exacta donde lees fuera del array o usas memoria ya liberada. En Visual Studio, la opción equivalente es /fsanitize=address.

Variación: convierte el ejercicio en una clase ListaEnteros con un método agregar(int) y un destructor que haga el delete[]. Después piensa qué pasa si copias una lista en otra con =. Ese problema se resuelve con la regla de los tres, y es el siguiente paso de cualquier asignatura de C++.

Cinco preguntas de "¿qué imprime?" que caen siempre

Intenta responder sin ejecutar el código. Las respuestas están debajo de cada una.

1. División entera y resto

cout << 7 / 2 << " " << 7 / 2.0 << " " << 7 % 3 << endl;

Imprime 3 3.5 1. Entre dos enteros, / es división entera. Basta con que uno de los dos sea decimal (2.0) para que el resultado lo sea. % es el resto de la división entera.

2. Un char es un número

char c = 'a';
cout << c + 1 << " " << char(c + 1) << endl;

Imprime 98 b. Al sumar, el char se convierte en int: la a es el 97 en ASCII. Para volver a ver una letra hay que convertir el resultado a char.

3. Paso por valor y por referencia

void dobla(int x) { x *= 2; }
void doblaRef(int& x) { x *= 2; }

int a = 5, b = 5;
dobla(a);
doblaRef(b);
cout << a << " " << b << endl;

Imprime 5 10. dobla trabaja sobre una copia de a, que desaparece al terminar la función. doblaRef recibe una referencia: trabaja sobre la b de verdad.

4. Asignar en lugar de comparar

int x = 5;
if (x = 0) {
    cout << "cero";
} else {
    cout << "no es cero";
}
cout << " " << x << endl;

Imprime no es cero 0. x = 0 no compara: asigna 0 a x, y el if evalúa ese 0 como falso. Así que entra por el else y además x ha cambiado. Compila sin errores, pero con -Wall el compilador avisa. Por eso conviene activarlo siempre.

5. Restar a un size_t

vector<int> v;
cout << v.size() - 1 << endl;

En un ordenador de 64 bits imprime 18446744073709551615. size() es un entero sin signo: no puede ser negativo, así que 0 − 1 da la vuelta al valor más grande posible. Por eso un bucle como for (size_t i = 0; i < v.size() - 1; i++) con el vector vacío no da cero vueltas: intenta dar trillones y se sale del vector.

Si has fallado alguna, no la memorices. Ejecútala con el depurador línea a línea y mira cómo cambian las variables. Tienes la técnica en cómo depurar código paso a paso.

Cómo practicar para que se quede

Escribe los pasos antes del código. Si no sabes explicar en castellano cómo resolverías el problema con papel y boli, el problema no es C++. Tres o cuatro comentarios con los pasos son la mitad del ejercicio.

Compila a menudo. Escribe cinco líneas, compila y prueba. Un error de compilación con 100 líneas nuevas es mucho más difícil de encontrar que con 5. Y lee el primer error que da el compilador, no el último: los demás suelen ser consecuencia del primero.

Prueba los casos raros. Vector vacío, un solo elemento, números negativos, el fichero que no existe. Los profesores corrigen con esos casos, y los jueces automáticos también. Si tu universidad usa uno, como Jutge.org en la UPC, un programa que falla con la entrada vacía se da por incorrecto aunque funcione con el ejemplo.

Practica sin ayudas si tu examen es sin ayudas. Si el examen es en papel o en un ordenador sin internet, practica sin autocompletado ni IA. Tienes cómo preparar el día del examen en cómo preparar un examen práctico de programación, y cómo pensar las funciones recursivas, que suelen caer en el mismo examen, en recursividad explicada con ejercicios resueltos.

Cuándo pedir ayuda

Vas bien si resuelves los diez ejercicios sin mirar la solución y sabes explicar por qué está cada línea. Merece la pena pedir ayuda cuando:

  • Entiendes las soluciones al leerlas, pero delante de un enunciado nuevo te quedas en blanco.
  • El programa da segmentation fault y no sabes ni por dónde empezar a buscar.
  • La asignatura ya va por clases, memoria dinámica o listas enlazadas y tú todavía dudas con las referencias.
  • Tienes un examen o una práctica cerca y no sabes qué priorizar.

En nuestras clases particulares de C y C++ online trabajamos justo esto: con tu guía docente, tus prácticas y tus exámenes de otros años. Dibujamos la memoria, seguimos el programa con el depurador y escribes tú el código hasta que te sale solo. Si estás en la carrera, tienes también nuestras clases de programación para universidad. Son clases uno a uno por videollamada a 25 € la hora, sin matrícula ni permanencia.

Preguntas frecuentes

¿Por dónde empiezo a hacer ejercicios de C++ si no sé nada?

Por ejercicios de pedir datos y mostrar resultados con condicionales, como el ejercicio 1. Después bucles y funciones, luego string y vector, y al final struct, ficheros, clases y memoria dinámica. Si todavía no tienes claro qué es una variable o un bucle, empieza por la ruta de cómo aprender programación desde cero.

¿Es mejor aprender C o C++ primero?

Si tu asignatura empieza con C, aprende C: los punteros y la memoria se entienden mejor sin nada que los esconda, y todo eso te sirve después en C++. Si empiezas directamente con C++, no hace falta pasar por C. Aprende string y vector desde el principio y deja new, delete y los punteros para cuando domines lo básico.

¿Qué programa uso para hacer los ejercicios de C++?

Cualquiera que use un compilador moderno. Los más habituales en la universidad son Code::Blocks (gratuito, y en Windows tiene un instalador que ya trae el compilador), VS Code con g++ o clang++, CLion (gratuito para uso no comercial y para estudiantes) y Visual Studio Community en Windows. Para probar algo rápido sin instalar nada sirven OnlineGDB o Compiler Explorer. Usa el mismo entorno que vas a tener en el examen.

¿En el examen puedo usar vector o tengo que usar arrays?

Depende de la asignatura. En muchas de primero los ejercicios se piden con arrays de tamaño fijo, porque el objetivo es entender cómo funcionan. En otras se usa la biblioteca estándar desde el principio. Mira los exámenes de otros años y, si no está claro, pregúntalo. Saber hacer los dos es lo que te da tranquilidad.

¿Está mal usar using namespace std?

En ejercicios, prácticas y exámenes de primero es lo habitual y nadie te lo va a penalizar. Evita ponerlo en ficheros de cabecera (.h), porque afecta a todo el código que los incluya y puede provocar conflictos de nombres. En proyectos grandes se suele escribir std::cout y std::vector.

¿Por qué mi programa da "segmentation fault"?

Porque accede a memoria que no le corresponde. Las causas típicas son salirse de un array o un vector, usar un puntero sin inicializar o ya liberado, y la recursividad infinita. En Linux o Mac, compila con -g -fsanitize=address y ejecútalo: te dirá la línea exacta. Si no, sigue el programa con el depurador hasta la línea donde se para. Si usas listas enlazadas o árboles, tienes los fallos típicos explicados en Estructuras de Datos en la universidad.

Documentación oficial

Comprobada en noviembre de 2026. La de cppreference está en inglés.

WhatsApp