Prog. orientada a objetos

Examen: Lo que debes saber

Temas

  1. Apuntadores y referencias en C++. Concepto de apuntador. Uso de * para declarar variables de tipo apuntador. Operadores para manipular direcciones de memoria y apuntadores: &, * y ->. Concepto de referencia. Uso de & para declarar variables de tipo referencia. Paso de parámetros por referencia vs paso de parámetros por valor. Uso del apuntador this dentro de un método.

  2. Herencia y polimorfismo en C++. Concepto de herencia. Modificadores de acceso: public, private y protected. Sobrecarga y sobreescritura de métodos. Métodos virtuales y virtuales puros. Concepto de polimorfismo. Clases abstractas y clases concretas. Diagramas de clases UML para representar herencia. Herencia vs composición. Concepto de upcasting y downcasting. Operadores static_cast y dynamic_cast.

  3. Sobrecarga de operadores en C++. Conceptos generales de sobrecarga de operadores. Ejemplos representativos de cómo sobrecargar operadores específicos. Sobrecarga de operadores dentro y fuera de una clase.

  4. Excepciones en C++. Concepto de excepción. Excepciones predefinidas en el encabezado <stdexcept>: std::exception, std::invalid_argument y std::runtime_error. El método what de una excepción. Manejo de excepciones usando las instrucciones throw, try y catch.

Artículos permitidos durante el examen

  1. Pluma, lápiz, borrador, sacapuntas.

  2. Acordeón personal de estudio con las siguientes características:


    1. Debe ser uno de los siguientes:

      • Tarjeta o ficha de trabajo de \(5 \times 8\) pulgadas (\(12.7 \times 20.32\) cm).

      • Media hoja tamaño carta (\(13.97 \times 21.59\) cm).

    2. Debe estar escritas a mano. No se permiten tarjetas/hojas impresas elaboradas en computadora.

    3. Está permitido escribir en ambos lados de la tarjeta/hoja.

    4. Debe incluir matrícula y nombre completo en la esquina superior izquierda de ambos lados de la tarjeta/hoja.

    5. No hay restricciones sobre el contenido específico escrito en la tarjeta/hoja.


NOTA 1: Una vez iniciado el examen, no se permite compartir ningún artículo con alguien más.

NOTA 2: No está permitido usar teléfono celular, calculadora, tableta, computadora o cualquier otro dispositivo electrónico.

Preguntas ejemplo

  1. ¿Qué imprime en la salida estándar el siguiente código de C++? 

    #include <iostream>

void fun(int a, int &b)
{
    a++;
    b++;
}

int main()
{
    int x = 5;
    int y = 5;
    std::cout << x << " " << y << "\n";
    fun(x, y);
    std::cout << x << " " << y << "\n";
    return 0;
}

  2. ¿Qué imprime en la salida estándar el siguiente código de C++? 

    #include <iostream>

int main()
{
    int i = 5;
    int &r = i;
    int *p = &i;
    i++;
    r++;
    (*p)++;
    std::cout << i << " " << r << " " << *p << "\n";
    return 0;
}

  3. El siguiente código de C++ produce un error de compilación. Explica porqué e indica cómo se podría corregir. 

    #include <iostream>

class A {
public:
    virtual void m() = 0;
};

class B : public A {
public:
};

int main()
{
    B b;
    b.m();
    return 0;
}

  4. ¿Qué imprime en la salida estándar el siguiente código de C++? 

    #include <iostream>
#include <vector>

class Alpha {
public:
    virtual void flimflam()
    {
        std::cout << "alpha\n";
    }
};

class Beta : public Alpha {
public:
    void flimflam() override
    {
        std::cout << "beta\n";
    }
};

class Gamma : public Alpha {
public:
    void bamboozle()
    {
        std::cout << "gamma\n";
    }
};

int main()
{
    Alpha a;
    Gamma g;
    Beta b;
    std::vector<Alpha*> vec = {&a, &g, &b};

    for (Alpha* p: vec) {
        p->flimflam();
        Gamma* q = dynamic_cast<Gamma*>(p);
        if (q) {
            q->bamboozle();
        }
    }

    return 0;
}

  5. Elabora el diagrama UML de la jerarquía de clases que aparecen en la pregunta anterior.

  6. Escribe el código necesario para representar una jerarquía de clases en C++ como se describe a continuación.

    Las clases deben ser: Animal, Perro y Gato. La clase Perro y Gato deben extender de la clase Animal.

    La clase Animal debe tener los siguientes dos atributos: nombre (cadena de caracteres) y edad (entero). Operaciones:

    • Constructor que inicialice los atributos.
    • virtual void hacer_sonido() const
      Método virtual puro para hacer el sonido característico del animal.
    • virtual void mostrar_informacion() const
      Método virtual puro para mostrar la información del animal.

    La clase Perro debe agregar el atributo raza (cadena de caracteres). Operaciones:

    • Constructor que inicialice los atributos (incluyendo los de la clase base).
    • Sobreescribe hacer_sonido() para imprimir el sonido característico del perro ("Guau").
    • Sobreescribe mostrar_informacion() para imprimir los datos específicos del perro.

    La clase Gato debe agregar el atributo color (cadena de caracteres). Operaciones:

    • Constructor que inicialice los atributos (incluyendo los de la clase base).
    • Sobreescribe hacer_sonido() para imprimir el sonido característico del perro ("Miau").
    • Sobreescribe mostrar_informacion() para imprimir los datos específicos del gato.

    Tus clases deben poder funcionar con el siguiente código: 

    void demostrar_animal(const Animal& a)
{
    a.mostrar_informacion();
    a.hacer_sonido();
}

int main()
{
    Perro p("Firulais", 5, "Labrador");
    Gato g("Michi", 3, "Negro");

    demostrar_animal(p);
    std::cout << "\n";
    demostrar_animal(g);
    return 0;
}

    Al correr el programa, esta debe ser su salida: 

    Perro:
Nombre: Firulais
Edad: 5
Raza: Labrador
Guau

Gato:
Nombre: Michi
Edad: 3
Color: Negro
Miau

  7. ¿Qué imprime en la salida estándar el siguiente código de C++? 

    #include <iostream>
#include <vector>

class Delta {
public:
    Delta(int x = 0)
    {
        _x = x;
    }
    int operator+() const {
        return _x + 1;
    }
    int operator+(const Delta &other) const {
        return (_x + other._x) * 2;
    }
private:
    int _x;
};

int main()
{
    Delta d(3);
    int r = +d * (d + d);
    std::cout << r << "\n";
    return 0;
}

  8. Explica para qué sirve el modificador de acceso private al momento de declarar los miembros de una clase.

  9. ¿Qué imprime en la salida estándar el siguiente código de C++? 

    #include <iostream>
#include <stdexcept>

void collywobbles(int x)
{
    std::cout << "a";
    if (x % 2 == 1) {
        throw std::runtime_error("b");
    }
    std::cout << "c";
    throw 10;
}

void crapulence(int y)
{
    try {
        std::cout << "d";
        collywobbles(y + 1);
        std::cout << "e";
    } catch (int) {
        std::cout << "f";
    }
    std::cout << "g";
}

int main()
{
    try {
        std::cout << "h";
        crapulence(1);
        std::cout << "i";
        crapulence(2);
        std::cout << "j";
    } catch (std::runtime_error e) {
        std::cout << e.what();
    }
    std::cout << "k";
    return 0;
}

  10. Usando un diagrama UML, explica la diferencia que existe entre herencia y composición.