Ingeniería en comunicaciones y electrónica
Tema 2.1 del Plan de Estudios de POO IPN
¡Hola, STEAMdiantes! hoy vamos a desmitificar uno de los pilares fundamentales de la programación moderna: la Programación Orientada a Objetos (POO), centrándonos en sus ladrillos básicos: las clases y los objetos. Si alguna vez te has preguntado cómo los programas complejos gestionan cientos de elementos diferentes sin volverse un caos, la respuesta está aquí.
Imagina que quieres construir un coche. No empezarías a soldar piezas al azar, ¿verdad? Primero, necesitarías un plano detallado: un documento que especifique las dimensiones, los materiales, qué motor usar, dónde van las ruedas, el color, etc. Ese plano es tu clase.
Ahora, una vez que tienes el plano, puedes usarlo para construir un coche real, o diez, o mil. Cada uno de esos coches físicos, construidos a partir de tu plano, es un objeto. Todos comparten la misma estructura definida en el plano, pero cada uno es una entidad única con sus propias características (uno puede ser rojo, otro azul; uno puede tener el tanque lleno y otro vacío).
Esa es la analogía central. En C++, es exactamente lo mismo.
Clases
Una clase es una plantilla o un molde que define las propiedades y comportamientos de un tipo de dato personalizado. Se compone de dos elementos principales:
Atributos: son las variables que almacenan las características o el estado de un objeto. Siguiendo nuestra analogía, serían el color, la marca, el modelo, el año, la velocidad actual, etc.
Métodos: son las funciones que definen las acciones o comportamientos que un objeto puede realizar. Para nuestro coche, serían acelerar(), frenar(), encenderLuces(), etc.
Veamos la sintaxis en C++ para crear una clase Coche:
// Declaración de la clase Coche
class Coche {
private:
// Atributos
// Son privados para protegerlos de modificaciones externas no controladas.
std::string marca;
std::string modelo;
int anio;
int velocidad;
public:
// Métodos
// Son públicos para que podamos interactuar con el objeto desde fuera.
void acelerar(int aumento);
void frenar(int decremento);
void mostrarInfo();
};Encapsulación
Habrás notado las palabras clave private y public. Este es uno de los conceptos más poderosos de la POO: la encapsulación.
private: los miembros declarados como privados solo son accesibles desde dentro de la misma clase. Es una caja negra. Protegemos nuestros atributos para que nadie pueda, por ejemplo, cambiar el año del coche (anio) a un valor negativo o poner la velocidad en 5000 km/h directamente. Es una medida de seguridad y consistencia.
public: los miembros públicos forman la “interfaz” de nuestro objeto. Son las funciones y variables a las que se puede acceder desde fuera de la clase. Es el volante, los pedales; son las herramientas que le damos al usuario para que interactúe de forma segura con la lógica interna del objeto.
Objetos
Ya tenemos nuestro plano (class Coche). Ahora, vamos a la “fábrica” (nuestra función main) y construyamos algunos coches reales. Crear un objeto a partir de una clase se llama instanciación.
#include <iostream>
#include <string>
// ... (Aquí iría la declaración de la clase Coche que vimos antes)
int main() {
// Creamos dos objetos (instancias) de la clase Coche
Coche miVocho;
Coche deportivoLujoso;
// A partir de aquí, miVocho y deportivoLujoso son dos entidades
// separadas en memoria, cada una con su propio conjunto de atributos.
return 0;
}¡Perfecto! Pero nuestros coches están… vacíos. No tienen marca, ni modelo, ni nada. Necesitamos una forma de inicializarlos y manipularlos.
Constructor
Un constructor es un método especial que se llama automáticamente en el momento en que se crea un objeto. Su principal trabajo es inicializar los atributos del objeto para que nazca en un estado válido y conocido.
El constructor tiene el mismo nombre que la clase y no tiene tipo de retorno (ni siquiera void). Modifiquemos nuestra clase Coche para incluir uno:
class Coche {
private:
std::string marca;
std::string modelo;
int anio;
int velocidad;
public:
// Constructor
Coche(std::string m, std::string mod, int a) {
marca = m;
modelo = mod;
anio = a;
velocidad = 0; // Todo coche nuevo empieza detenido.
std::cout << "¡Se ha construido un " << marca << " " << modelo << "!" << std::endl;
}
// ... (El resto de métodos)
};Ahora, al crear los objetos, debemos proporcionar los datos que el constructor nos pide:
int main() {
// Creamos objetos usando el constructor
Coche miVocho("Volkswagen", "Sedan", 1998);
Coche deportivoLujoso("Ferrari", "F8 Tributo", 2024);
return 0;
}Al ejecutar este código, verás los mensajes del constructor, confirmando que los objetos fueron creados.
Ya tenemos los planos y los objetos inicializados. Es hora de usarlos. Para llamar a un método público o acceder a un miembro público de un objeto, usamos el operador punto (.).
Vamos a implementar los métodos que dejamos pendientes y a poner todo junto en un ejemplo completo.
#include <iostream>
#include <string>
class Coche {
private:
std::string marca;
std::string modelo;
int anio;
int velocidad;
public:
// Constructor para inicializar el objeto
Coche(std::string m, std::string mod, int a) {
marca = m;
modelo = mod;
anio = a;
velocidad = 0; // Estado inicial seguro
std::cout << "-> Objeto Coche creado: " << marca << " " << modelo << " (" << anio << ")" << std::endl;
}
// Método para acelerar de forma controlada
void acelerar(int aumento) {
if (aumento > 0) {
velocidad += aumento;
std::cout << "Acelerando... Velocidad actual: " << velocidad << " km/h" << std::endl;
}
}
// Método para frenar de forma controlada
void frenar(int decremento) {
if (decremento > 0) {
velocidad -= decremento;
if (velocidad < 0) {
velocidad = 0; // No podemos tener velocidad negativa
}
std::cout << "Frenando... Velocidad actual: " << velocidad << " km/h" << std::endl;
}
}
// Método para mostrar la información del coche
void mostrarInfo() {
std::cout << "-------------------------" << std::endl;
std::cout << "Marca: " << marca << std::endl;
std::cout << "Modelo: " << modelo << std::endl;
std::cout << "Año: " << anio << std::endl;
std::cout << "Velocidad: " << velocidad << " km/h" << std::endl;
std::cout << "-------------------------" << std::endl;
}
};
int main() {
// Creamos una instancia de Coche
Coche miCarrera("Porsche", "911 Carrera", 2025);
// Interactuamos con el objeto
miCarrera.mostrarInfo();
miCarrera.acelerar(50);
miCarrera.acelerar(30);
miCarrera.frenar(20);
miCarrera.mostrarInfo();
return 0;
}Salida esperada:
-> Objeto Coche creado: Porsche 911 Carrera (2025)
-------------------------
Marca: Porsche
Modelo: 911 Carrera
Año: 2025
Velocidad: 0 km/h
-------------------------
Acelerando... Velocidad actual: 50 km/h
Acelerando... Velocidad actual: 80 km/h
Frenando... Velocidad actual: 60 km/h
-------------------------
Marca: Porsche
Modelo: 911 Carrera
Año: 2025
Velocidad: 60 km/h
-------------------------Entender las clases y los objetos es dar un salto gigante en tu carrera como desarrollador. Te permite organizar tu código de una manera lógica, modular y reutilizable, reflejando el mundo real. Piensa en cualquier aplicación compleja: un videojuego tiene clases para Enemigo, Jugador, Arma; una aplicación bancaria tiene clases para Cliente, CuentaBancaria, Transaccion.
Mi consejo es simple: practica. No te quedes solo con el coche. Modela un Estudiante, una Laptop, un Pokemon. Define sus atributos, sus métodos y crea objetos para interactuar con ellos. No temas experimentar y cometer errores; así es como realmente se forja el conocimiento de un ingeniero.
Gracias por leernos.
Si te gusto este artículo, únete a nuestra comunidad en Facebook o WhatsApp para más…
¡Hasta la próxima!
