[ES] Sintáxis básica de C++ (parte 2)

// persona.h

// Estas líneas (llamadas directrices de preprocesador,
// que, en este caso, forman un "include guard") le
// indican al compilador que lea este archivo sólo
// una vez, en caso de que sea utilizado en más de un sitio.
// Todo archivo .h debiera utilizarlas
#ifndef PERSONA_H
#define PERSONA_H

// Una alternativa no estándar pero soportada por la
// mayoría de los compiladores es #pragma once. Si usaran
// esta forma, omitan el include guard (las líneas que parten
// con #ifndef y #define y la línea #endif al final del
// documento). Solo deberían usar una de estas a la vez.
#pragma once

#include <string>

// Una clase puede tener miembros:
//   - públicos (accesibles por cualquiera)
//   - privados (accesibles sólo por la clase misma)
//   - protegidos (accesibles sólo por la clase
//     misma y sus subclases)

class Persona {
// Estos no podrán ser accedidos desde fuera de la clase.
// Si tuviéramos una instancia de Persona llamada p,
// escribir p.nombre va a generar un error de compilación
private:
    // Tanto nombre como edad se denominan atributos
    // (o campos). Funcionan como variables, las cuales
    // serán únicas para cada instancia de Persona (es
    // decir, cada persona tendrá su propio nombre y edad)
    std::string nombre;
    unsigned edad;

// En cambio, estos pueden utilizarse desde fuera y funcionan
// como la cara visible de la clase
public:
    // Este es el constructor (puede haber más de uno), donde
    // se inicializa cada instancia de la clase, se definen
    // sus valores iniciales, entre otras cosas. Un
    // constructor no especifica un tipo de retorno.
    Persona(std::string nombre, unsigned edad);

    // Estas funciones se denominan métodos. Los métodos
    // pueden acceder a los atributos de cada instancia y
    // trabajar con estos.
    std::string get_nombre();
    unsigned get_edad();
};

#endif // PERSONA_H      Omitir si usan #pragma once

// clase.cpp

// En este archivo vamos a implementar tanto el
// constructor como los dos métodos que están definidos
// en el archivo de cabecera.

#include "persona.h"

// Para implementar los métodos de una clase,
// anteponemos al nombre de cada uno el de la clase,
// seguido de ::
Persona::Persona(std::string nombre, unsigned edad)
  : nombre(nombre), edad(edad) {
    // Esta de arriba es una notación especial que nos
    // permite asignar directamente el valor de cada
    // argumento con un atributo de la clase (en este
    // caso, el atributo nombre recibe el valor del
    // parámetro del mismo nombre; lo mismo con edad)

    // Podemos hacer esto en lugar de la forma
    // anterior si gustan
    // this->nombre = nombre;
    // this->edad = edad;

    // El puntero this nos permite acceder a todos los
    // atributos de la instancia actual de la clase.
    // La usamos en este caso para evitar ambigüedades
    // (ya que atributo y parámetro se llaman igual)
}

std::string Persona::get_nombre() {
    // Como en este caso no hay otro elemento llamado
    // nombre en la función, podemos prescindir del
    // this-> con seguridad
    return nombre;
}

unsigned Persona::get_edad() {
    return edad;
}

// main.cpp

// Los archivos de cabecera que son parte del proyecto
// debieran ser incluidos usando comillas dobles (""),
// mientras que las librerías de sistema con <>
#include <iostream>
#include "persona.h"

int main() {
    // Así creamos una instancia cuyo atributo
    // nombre contendrá el string "Juan López"
    // y edad el número 40. Noten que los argumentos
    // dados coinciden con los parámetros definidos
    // en persona.cpp y persona.h
    Persona p("Juan López", 40);

    std::cout << p.get_nombre() << " tiene "
              << p.get_edad() << " años.\n";

    // Retornamos 0 para indicar que el programa
    // se ejecutó exitosamente
    return 0;
}

g++ -o prueba_persona main.cpp persona.cpp

prueba_persona/
 |-- src/                 Archivos fuente
 |    |- main.cpp
 |    \- persona.cpp
 \-- include/             Archivos de cabecera
      \- persona.h

g++ -o prueba_persona src/main.cpp src/persona.cpp -I include/

class Clase {
private:
    std::string nombre;
    unsigned edad;
public:
    Clase();
    Clase(std::string nombre, unsigned edad);
};

Clase::Clase() : nombre(""), edad(0) {
    // ...
}

Clase::Clase(std::string nombre, unsigned edad)
  : nombre(nombre), edad(edad) {
    // ...
}

class ClaseConDtor {
private:
    std::string str;
public:
    ClaseConDtor();
    ~ClaseConDtor(); // Este es nuestro destructor.
                     // Un destructor nunca recibe
                     // argumentos
}

if (...) {
    ClaseConDtor a(); // Creamos una instancia

    // ...
}
// Al momento de abandonar el if, el destructor
// es llamado automáticamente. El atributo str
// también invoca al suyo y libera la memoria
// que utilizaba el string

class ClaseConDtorMem {
private:
    // ...
public:
    ClaseConDtorMem();
    ~ClaseConDtorMem();
}

// Creamos una instancia en el heap
// (traten de usar punteros lo menos posible, insisto)
ClaseConDtorMem *c = new ClaseConDtorMem();

// ...

delete c; // Aquí invocamos al destructor de nuestra
          // clase. Una vez hecho, la memoria que
          // solicitó es devuelta al SO

// Este arreglo es de tamaño fijo. Podemos
// alterar los números que ya contiene, pero
// no podemos agregarle ni quitarle celdas.
int nums[] = {0, 1, 1, 2, 3, 5, 8};

nums[8] = 13; // A menos que quieran que su programa
              // falle o no compile, no hagan esto.

#include <iostream>

#include <vector> // Tenemos que incluir esta librería
                  // para usar vectores

#include "persona.h"

// Como nums2 es un vector, podemos alterar los números
// que contiene, agregar y eliminar a libertad.
std::vector<int> nums2{0, 1, 1, 2, 3, 5, 8};

nums2.push_back(13); // Así agregamos un número al final
int trece = nums2.pop_back(); // Y así lo eliminamos

// Así podemos obtener el tamaño del vector
std::cout << nums2.size() << std::endl;

// Así inicializamos un vector vacío
std::vector<Persona> gente;

// Y así podemos construir "in situ" una instancia,
// si es que el tipo es construible. Tan solo tenemos
// que pasar los mismos parámetros que de costumbre.
gente.emplace_back("Alan Turing", 41);

// Eso es equivalente a esto:
Persona alan("Alan Turing", 41);
gente.push_back(alan);

// Si queremos limpiar el vector, llamamos a clear()
gente.clear();

// Para comprobar que lo limpiamos, podemos usar
// el método empty() o chequear que size() == 0
if (gente.empty()) {
    std::cout << "Vacío" << std::endl;
}

// if (gente.size() == 0) {
//    std::cout << "Vacío" << std::endl;
// }

#include <list>

// Una lista doblemente enlazada
std::list<int> lista{1, 2, 3, 4, 5};

lista.push_back(6);

// Ahora la lista queda
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6

lista.push_front(7);

// Ahora la lista queda
// 7 <-> 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6

lista.pop_back();
lista.pop_back();
lista.pop_front();

// Finalmente:
// 1 <-> 2 <-> 3 <-> 4

std::list<int> fibonacci{0, 1, 1, 2, 3, 5, 8, 13};

// Iteración regular (de inicio a fin)
for (int n : fibonacci) {
    std::cout << n << std::endl;
}

// Iteración en reversa
auto it = fibonacci.rbegin();
auto end = fibonacci.rend();
for (; it != end; ++it) {
    std::cout << n << std::endl;
}

// El tipo auto nos permite omitir el tipo de una variable
// si es muy largo y deja su determinación a cargo del
// compilador

// La anterior sintaxis no es la más cómoda (de hecho,
// es una de las razones por las que puse el iterador
// inicial y de fin en líneas aparte para mejorarlo
// un poco), pero desde C++20 en adelante existe una
// forma mucho más simple que podemos usar, gracias
// a la nueva librería ranges

#include <ranges>

for (int n : fibonacci | std::views::reverse) {
    std::cout << n << std::endl;
}

// El operador tubería (|) le entrega la lista a
// std::views::reverse, el cual invierte los iteradores
// y permite recorrerlo en reversa con menos código

#include <forward_list>

std::forward_list<int> simple{1, 2, 3};

// Iteración regular (de inicio a fin)
for (int n : simple) {
    std::cout << n << std::endl;
}

// ESTO NO VA A FUNCIONAR
auto it = simple.rbegin();
auto end = simple.rend();
for (; it != end; ++it) {
    std::cout << n << std::endl;
}