Es hora de entrar en uno de los paradigmas centrales de C++: la programación orientada a objetos (POO).
La POO gira en torno a classes, tipos de datos definidos por el usuario que tienen su propio conjunto de funciones relacionadas.
Empezaremos con lo básico y cubriremos temas más avanzados más adelante en el temario.
Las clases pueden tener variables miembro y funciones miembro.
Se accede a ellas con el operador . de selección de miembros.
Al igual que con las variables fuera de las classes, es recomendable inicializar las variables miembro con un valor al declararlas.
Ese valor pasa a ser entonces el predeterminado para los objetos de esta clase que se creen.
Las clases ofrecen la opción de restringir el acceso a sus miembros.
Los dos access specifiers básicos son private y public.
No se puede acceder a los miembros private desde fuera de la clase.
Se puede acceder libremente a los miembros public.
Todos los miembros de una class son private de forma predeterminada.
Solo los miembros marcados explícitamente con public se pueden usar libremente fuera de la clase.
La definición de una class se puede ver en el siguiente ejemplo.
Fíjate en el ; después de la definición:
class Wizard {
public: // from here on all members are publicly accessible
int cast_spell() { // defines the public member function cast_spell
return damage;
}
std::string name{}; // defines the public member variable `name`
private: // from here on all members are private
int damage{5}; // defines the private member variable `damage`
};
Puedes acceder a todas las variables miembro desde dentro de la clase.
Echa un vistazo a damage dentro de la función cast_spell.
No puedes leer ni cambiar los miembros private desde fuera de la clase:
Wizard silverhand{};
// calling the `cast_spell` function is okay, it is public:
silverhand.cast_spell();
// => 5
// name is public and can be changed:
silverhand.name = "Laeral";
// damage is private:
silverhand.damage = 500;
// => Compilation error
Los constructores ofrecen la posibilidad de asignar valores a las variables miembro al crear un objeto.
Tienen el mismo nombre que la class y no tienen tipo de retorno.
Una clase puede tener varios constructores.
Esto es útil si no siempre necesitas establecer todas las variables.
A veces puede que quieras mantener todo en sus valores predeterminados, pero cambiar la variable name.
En el caso de un Wizard importante, quizá quieras cambiar también el damage, así que necesitas dos constructors.
class Wizard {
public:
Wizard(std::string new_name) {
name = new_name;
}
Wizard(std::string new_name, int new_damage) {
name = new_name;
damage = new_damage;
}
int cast_spell() {
return damage;
}
std::string name{};
private:
int damage{5};
};
Wizard el{"Eleven"}; // deals 5 damage
Wizard vecna{"Vecna", 50}; // deals 50 damage
Los constructores son un tema amplio y tienen muchos matices.
Si no defines explícitamente un constructor para tu class, entonces (y solo entonces) el compilador hará el trabajo por ti.
Eso es lo que ocurrió en el primer ejemplo de arriba.
El objeto silverhand se crea llamando al constructor predeterminado, sin pasar ningún argumento.
Todas las variables se establecen con el valor indicado en la definición de la clase.
Si no hubieras dado ningún valor en esa definición, es posible que las variables quedaran sin inicializar, lo que podría tener consecuencias no deseadas.
Los structs provienen de las raíces originales del lenguaje en C y son tan antiguos como el propio C++.
En esencia, son lo mismo que classes con una excepción importante.
De forma predeterminada, todo en una class es private.
Los structs, en cambio, son public hasta que se defina lo contrario.
Por convención, la palabra clave struct se usa a menudo para estructuras que solo contienen datos.
La palabra clave class se prefiere para objetos que necesitan garantizar ciertas propiedades.
Un invariante así podría ser que el damage de tu class Wizard no pueda volverse negativo.
La variable damage es privada y cualquier función que cambie el damage se aseguraría de que el invariante se conserve.
Ellen está creando un juego en el que el jugador tiene que pelear contra aliens.
Acaba de aprender sobre Programación Orientada a Objetos (POO) y está ansiosa por aprovechar lo que el uso de classes podría ofrecerle a su programa.
Para alegría de Ellen, te has ofrecido a ayudar y ella te ha encargado la tarea de programar a los aliens contra los que el jugador tiene que pelear.
Alien
Define la clase Alien con un constructor que acepte dos parámetros int, x y y, y los guarde en las variables miembro x_coordinate y y_coordinate.
Cada alien también empezará con un nivel de salud de 3, así que la variable miembro health también debe inicializarse.
health debe ser una variable miembro privada.
Para que otras partes del programa puedan leer la información de salud, Ellen quiere tener un método public get_health() que devuelva un int.
Alien alien{2, 0};
alien.x_coordinate;
// => 2
alien.y_coordinate;
// => 0
alien.get_health();
// => 3
Ahora, cada alien debe poder hacer un seguimiento interno de su propia posición y salud.
hit
A Ellen le gustaría que la class Alien tenga un método hit que reduzca en 1 la salud de un objeto alien cuando se llame.
Así, puede simplemente llamar a some_alien_instance.hit() en lugar de tener que cambiar manualmente la salud de un alien.
Asegúrate de que los puntos de salud no bajen por debajo de cero.
La función debe devolver true.
Ellen quiere introducir escudos más adelante, que entonces reportarían false si el escudo está activo.
Alien alien {0, 0};
alien.get_health();
// => 3 (Initial health value)
alien.hit(); // Decrements health by 1 point.
alien.get_health();
// => 2
is_alive
Te das cuenta de que, si la salud sigue bajando, en algún momento probablemente llegará a 0.
Sería buena idea agregar un método is_alive al que Ellen pueda llamar rápidamente para comprobar si el alien está... bueno... vivo. 😉
some_alien_instance.is_alive() debe devolver un Boolean.
alien.get_health();
// => 1
alien.is_alive();
// => true
alien.hit();
alien.get_health();
// => 0
alien.is_alive();
// => false
teleport
¡En el juego de Ellen los aliens pueden teletransportarse!
Tendrás que escribir un método teleport que tome los valores x_new y y_new y cambie las coordenadas del alien en consecuencia.
Por ahora, la función debe devolver true.
Ellen quiere agregar bombas que bloqueen el teletransporte en niveles posteriores, que entonces reportarían false para los intentos de teletransporte fallidos.
alien.teleport(5, -4);
alien.x_coordinate;
// => 5
alien.y_coordinate;
// => -4
collision_detection
Si algo puede golpear a los aliens, entonces necesitan poder detectar cuándo podría ocurrir una colisión así.
Ellen necesita saber si dos aliens ocupan las mismas coordenadas.
La función collision_detection() toma otro objeto alien como argumento y devuelve un bool.
Alien lrrr {3, 6};
Alien ndnd {-2, 12};
lrrr.collision_detection(ndnd);
// => false
ndnd.teleport(3, 6);
ndnd.collision_detection(lrrr);
// => true
Regístrate en Exercism para aprender y dominar C++ con 19 conceptos100 ejercicios y mentoría humana real, todo gratis.