C++ soporta la programación orientada a objetos (OOP o POO).

En este post vamos a ver cómo trabajar con clases y objetos de CPP, vamos a ver cómo se define una clase y cómo se crea una instancia de la misma, además de ver los getters, setters, modificadores de acceso, propiedades y métodos.

Nota: comenzaré explicando cómo funcionan las clases y objetos en CPP, y al final dejaré un ejemplo de código de una clase y la creación de objetos.

Definición de una clase en C++

La definición es así:

class NombreDeLaClase{};

Dentro del cuerpo de la clase se definen los apartados de acceso, que pueden ser public, private o protected. Y dentro de cada apartado se define la propiedad o método.

También se define el constructor, en el apartado público. Recuerda que el constructor es una función especial que es llamada cuando se crea el objeto.

Tipos de acceso

Los tipos de acceso se definen dentro de la clase, con el tipo seguido de dos puntos. Por ejemplo:

public:

Público

Cuando ponemos un método o propiedad como público, se puede acceder al mismo desde fuera de la clase, y también desde dentro. Con “fuera de la clase” quiere decir que se puede llamar directamente desde el objeto.

Por ejemplo, suponiendo que perro es un objeto de la clase Animal y tiene un método público llamado dormir, podríamos invocarlo así:

perro.dormir()

También puede ser llamado desde otro método que existe dentro de la clase:

this->dormir();

De igual manera puede ser invocado desde clases que heredan de esta clase; es decir, puede ser llamado desde cualquier lugar.

Lo mismo aplica para las propiedades.

Privado

Cuando se declara algo como privado, solo se puede acceder desde dentro de la clase.

Suponiendo que existe el método privado llamado ladrar, y que perro es una instancia de la clase Animal, no podemos hacer esto:

perro.ladrar()

Solo se puede desde dentro de la clase:

this->ladrar();

Lo mismo aplica para las propiedades.

Protected o protegido

Funciona como lo privado, pero con una excepción: las subclases de esta clase pueden acceder a ellos.

Es decir, desde fuera de la clase no se puede acceder, pero sí desde dentro de la clase y desde dentro de cualquier clase que herede de la misma.

Con el modificador private, no se puede acceder ni desde subclases; con protected sí.

Constructor

El constructor debe ser público y debe tener el mismo nombre que la clase. Puede recibir parámetros y sobrecargarse, es decir, llamarse del mismo modo pero tener distinto número de argumentos.

En el constructor se suelen iniciar variables o “preparar” el objeto para su posterior uso y no siempre es obligatorio.

Getters y setters

Por buenas prácticas las propiedades deberían ser privadas y exponerse con métodos públicos; por eso existen estos métodos que se encargan de establecer y devolver las variables.

Los getters llevan la sintaxis de getPropiedad  los setters la sintaxis de setPropiedad.

Instanciar un objeto

Para crear un objeto de determinada clase, cuyo constructor no tiene argumentos, la sintaxis es:

NombreDeClase nombreDeObjeto;

Si el constructor tiene argumentos, es así:

NombreDeLaClase nombreDeObjeto(argumento1, argumento2...);

Por ejemplo:

Animal perro ("Maggie");

Si las propiedades son públicas, podemos establecerlas:

perro.edad = 2;

Y si están expuestas con un setter:

perro.setEdad(2);

También se pueden llamar a métodos normalmente:

perro.comer()

Y obtener las propiedades:

int edadDelPerro = perro.getEdad();

Ejemplo de clase en C++

Veamos un ejemplo de código:

#include <iostream>
class Persona {
 private:
  std::string nombre;
  int edad;

  void metodoPrivado() { std::cout << "Llamada privada dentro de la clase\n"; }

 public:
  // Constructor sin argumentos
  Persona() {
    std::cout << "Se llama al constructor sin argumentos\n";
    this->metodoPrivado();
  }
  // Constructor con nombre y edad
  Persona(std::string nombre, int edad) {
    this->edad = edad;
    this->nombre = nombre;
  }

  int getEdad() { return this->edad; }

  void setEdad(int edad) { this->edad = edad; }

  std::string getNombre() { return this->nombre; }

  void setNombre(std::string nombre) { this->nombre = nombre; }

  void saludar() {
    std::cout << "Hola, me llamo " << this->nombre << " y mi edad es "
              << this->edad << "\n";
  }
};

int main() {
  // Crear persona con argumentos
  Persona p1("Luis", 21);
  p1.saludar();
  // Obtener su edad
  int edad = p1.getEdad();
  // Crear otra persona, sin argumentos
  Persona p2;
  // Establecer valores por separado
  p2.setEdad(1);
  p2.setNombre("John Galt");
  p2.saludar();
}

Fíjate en que cada cosa que dijimos se refleja en el mismo.