Relaciones entre clases y objetos: fundamentos y ejemplos en C++

Ingeniería en comunicaciones y electrónica
Tema 1.3 del Plan de Estudios de POO IPN

En la Programación Orientada a Objetos (POO), las clases y los objetos son los pilares fundamentales. Pero para construir sistemas más complejos, es crucial entender cómo estas entidades se relacionan entre sí.

En este artículo, exploraremos los principales tipos de relaciones entre clases y objetos en C++, con ejemplos claros para estudiantes que están aprendiendo.

¿Qué son clases y objetos?

Antes de hablar de relaciones, repasemos los conceptos básicos:

• Clase: Es una plantilla o molde que define atributos (datos) y métodos (funciones).
• Objeto: Es una instancia concreta de una clase, creada en tiempo de ejecución.

Ejemplo básico en C++:

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

class Perro {
public:
    string nombre;
    int edad;

    void ladrar() {
        cout << nombre << " dice: ¡Guau!" << endl;
    }
};

int main() {
    Perro miPerro;
    miPerro.nombre = "Rex";
    miPerro.edad = 3;
    miPerro.ladrar();
    return 0;
}

Principales relaciones entre clases

En C++, las clases pueden interactuar de diferentes maneras. Las relaciones más comunes son:

Asociación (uso temporal)

Ocurre cuando una clase usa a otra, pero no la posee. Puede ser unidireccional o bidireccional.
Ejemplo: un estudiante usa un libro, pero no lo posee.

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

class Libro {
public:
    string titulo;
};

class Estudiante {
public:
    void estudiar(Libro &libro) {   // Asociación por referencia
        cout << "Leyendo: " << libro.titulo << endl;
    }
};

int main() {
    Libro libroFavorito;
    libroFavorito.titulo = "El Principito";

    Estudiante juan;
    juan.estudiar(libroFavorito);   // Salida: Leyendo: El Principito
    return 0;
}

Agregación (tiene-un, relación débil)

Una clase contiene objetos de otra, pero estos pueden existir independientemente.
Ejemplo: un departamento tiene profesores, pero si el departamento desaparece, los profesores siguen existiendo.

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

class Profesor {
public:
    string nombre;
};

class Departamento {
public:
    vector<Profesor*> profesores;  // Agregación (usamos punteros)

    void agregarProfesor(Profesor *prof) {
        profesores.push_back(prof);
    }
};

int main() {
    Profesor prof1{"Ana"};
    Profesor prof2{"Luis"};

    Departamento matematicas;
    matematicas.agregarProfesor(&prof1);
    matematicas.agregarProfesor(&prof2);

    // Si 'matematicas' se destruye, 'prof1' y 'prof2' siguen existiendo
    return 0;
}

Composición (posee-un, relación fuerte)

Una clase posee objetos de otra, y estos no tienen sentido sin ella. Si la clase principal se destruye, sus componentes también.
Ejemplo: un automóvil tiene un motor, pero si el auto se destruye, el motor deja de existir.

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

class Motor {
public:
    void encender() {
        cout << "Motor encendido" << endl;
    }
};

class Automovil {
private:
    Motor motor;  // Composición (el motor es parte del auto)

public:
    void arrancar() {
        motor.encender();
        cout << "Auto listo para moverse" << endl;
    }
};

int main() {
    Automovil miAuto;
    miAuto.arrancar();  // Salida: Motor encendido → Auto listo para moverse
    return 0;
}

Herencia (es-un, relación jerárquica)

Una clase hereda atributos y métodos de otra, permitiendo reutilizar código.
Ejemplo: un gato es un tipo de animal.

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

class Animal {
public:
    void comer() {
        cout << "Comiendo..." << endl;
    }
};

class Gato : public Animal {  // Herencia (Gato ES-UN Animal)
public:
    void maullar() {
        cout << "¡Miau!" << endl;
    }
};

int main() {
    Gato garfield;
    garfield.comer();   // Método heredado
    garfield.maullar(); // Salida: Comiendo... ¡Miau!
    return 0;
}

¿Cuándo usar cada relación?

Entender las relaciones entre clases y objetos es esencial para diseñar sistemas modulares, reutilizables y mantenibles. En C++, estas relaciones se implementan mediante:

• Referencias/Punteros (Asociación/Agregación).
• Objetos como miembros (Composición).
• Herencia (Extensión de clases).

Si quieres profundizar, investiga sobre Dependency Injection (inyección de dependencias), una técnica avanzada que usa asociaciones para hacer el código más flexible.

Gracias por leernos.
Si te gusto este artículo, únete a nuestra comunidad en Telegram o WhatsApp para más…
¡Hasta la próxima!