En esta segunda parte de esta serie veremos uno de los principales elementos que distinguen a C++ de su antecesor: las clases. Además, haremos un pequeño paseo por algunos contenedores básicos que ofrece la STL.
\nLas clases son la piedra angular de la programación orientada a objetos. Básicamente son armazones con los cuales uno crea objetos que pueden contener datos y que, además, pueden operar con esos datos. Una clase, por lo general, va a estar compuesta de dos archivos: un archivo de cabecera (generalmente usando la extensión .h o .hpp), que define su estructura, y un archivo fuente (.cpp, .cxx, .cc, entre otras; queda a gusto del programador cuál usar), que implementa el código definido por la estructura.
El archivo de cabecera de una clase puede verse de la siguiente forma:
\n// persona.h\n\n// Estas líneas (llamadas directrices de preprocesador,\n// que, en este caso, forman un \"include guard\") le\n// indican al compilador que lea este archivo sólo\n// una vez, en caso de que sea utilizado en más de un sitio.\n// Todo archivo .h debiera utilizarlas\n#ifndef PERSONA_H\n#define PERSONA_H\n\n// Una alternativa no estándar pero soportada por la\n// mayoría de los compiladores es #pragma once. Si usaran\n// esta forma, omitan el include guard (las líneas que parten\n// con #ifndef y #define y la línea #endif al final del\n// documento). Solo deberían usar una de estas a la vez.\n#pragma once\n\n#include <string>\n\n// Una clase puede tener miembros:\n// - públicos (accesibles por cualquiera)\n// - privados (accesibles sólo por la clase misma)\n// - protegidos (accesibles sólo por la clase\n// misma y sus subclases)\n\nclass Persona {\n// Estos no podrán ser accedidos desde fuera de la clase.\n// Si tuviéramos una instancia de Persona llamada p,\n// escribir p.nombre va a generar un error de compilación\nprivate:\n // Tanto nombre como edad se denominan atributos\n // (o campos). Funcionan como variables, las cuales\n // serán únicas para cada instancia de Persona (es\n // decir, cada persona tendrá su propio nombre y edad)\n std::string nombre;\n unsigned edad;\n\n// En cambio, estos pueden utilizarse desde fuera y funcionan\n// como la cara visible de la clase\npublic:\n // Este es el constructor (puede haber más de uno), donde\n // se inicializa cada instancia de la clase, se definen\n // sus valores iniciales, entre otras cosas. Un\n // constructor no especifica un tipo de retorno.\n Persona(std::string nombre, unsigned edad);\n\n // Estas funciones se denominan métodos. Los métodos\n // pueden acceder a los atributos de cada instancia y\n // trabajar con estos.\n std::string get_nombre();\n unsigned get_edad();\n};\n\n#endif // PERSONA_H Omitir si usan #pragma once// clase.cpp\n\n// En este archivo vamos a implementar tanto el\n// constructor como los dos métodos que están definidos\n// en el archivo de cabecera.\n\n#include \"persona.h\"\n\n// Para implementar los métodos de una clase,\n// anteponemos al nombre de cada uno el de la clase,\n// seguido de ::\nPersona::Persona(std::string nombre, unsigned edad)\n : nombre(nombre), edad(edad) {\n // Esta de arriba es una notación especial que nos\n // permite asignar directamente el valor de cada\n // argumento con un atributo de la clase (en este\n // caso, el atributo nombre recibe el valor del\n // parámetro del mismo nombre; lo mismo con edad)\n\n // Podemos hacer esto en lugar de la forma\n // anterior si gustan\n // this->nombre = nombre;\n // this->edad = edad;\n\n // El puntero this nos permite acceder a todos los\n // atributos de la instancia actual de la clase.\n // La usamos en este caso para evitar ambigüedades\n // (ya que atributo y parámetro se llaman igual)\n}\n\nstd::string Persona::get_nombre() {\n // Como en este caso no hay otro elemento llamado\n // nombre en la función, podemos prescindir del\n // this-> con seguridad\n return nombre;\n}\n\nunsigned Persona::get_edad() {\n return edad;\n}Luego, para utilizar la clase en nuestro código, podemos hacer lo siguiendo, sin olvidar incluir el archivo .cpp entre los que el compilador va a recibir:
\n// main.cpp\n\n// Los archivos de cabecera que son parte del proyecto\n// debieran ser incluidos usando comillas dobles (\"\"),\n// mientras que las librerías de sistema con <>\n#include <iostream>\n#include \"persona.h\"\n\nint main() {\n // Así creamos una instancia cuyo atributo\n // nombre contendrá el string \"Juan López\"\n // y edad el número 40. Noten que los argumentos\n // dados coinciden con los parámetros definidos\n // en persona.cpp y persona.h\n Persona p(\"Juan López\", 40);\n\n std::cout << p.get_nombre() << \" tiene \"\n << p.get_edad() << \" años.\\n\";\n\n // Retornamos 0 para indicar que el programa\n // se ejecutó exitosamente\n return 0;\n}Podríamos compilar el programa con esta llamada a g++:
g++ -o prueba_persona main.cpp persona.cppSi desean mantener los archivos de cabecera y fuente separados, pueden hacer uso\nde esta estructura de archivos:
\nprueba_persona/\n |-- src/ Archivos fuente\n | |- main.cpp\n | \\- persona.cpp\n \\-- include/ Archivos de cabecera\n \\- persona.hPara compilar, pueden usar este comando (asegurándose de estar en la carpeta prueba_persona):
g++ -o prueba_persona src/main.cpp src/persona.cpp -I include/El argumento -I <carpeta> le indica al compilador dónde tiene que buscar los archivos .h que hemos creado, ya que no están en la misma carpeta que los .cpp.
Antes de continuar, me quiero detener un momento para explicar un poco más sobre los contenedores y destructores, también llamados ctor(s) y dtor(s) (a partir de los términos constructor(s) y destructor(s) en inglés). Estos dos son métodos especiales dentro de una clase y son llamados al momento de crear una instancia de esta o cuando el objeto se sale de scope o se invoca a delete, respectivamente (veremos estos últimos dos casos en detalle después).
Como mencionaba, los constructores se ejecutan al momento de crear una instancia de clase. Por lo general se encargan de inicializar los atributos de la nueva instancia y, por tanto, puede recibir argumentos de parte del programador. También es posible definir más de un constructor en caso de ser necesario.
\nCabe también agregar que si no definimos un constructor en nuestra clase, el compilador nos proveerá uno trivial. Además, los atributos que puedan construirse por defecto (como los contenedores y tipos de la STL) lo harán automáticamente, añadamos o no un constructor.
\nclass Clase {\nprivate:\n std::string nombre;\n unsigned edad;\npublic:\n Clase();\n Clase(std::string nombre, unsigned edad);\n};\n\nClase::Clase() : nombre(\"\"), edad(0) {\n // ...\n}\n\nClase::Clase(std::string nombre, unsigned edad)\n : nombre(nombre), edad(edad) {\n // ...\n}En este ejemplo, podemos ver que Clase(std::string, unsigned) asignará el nombre y edad que le entregamos a los atributos del mismo nombre, lo que es usual. Con respecto a Clase(), lo que ocurrirrá es que tanto nombre como edad se definan como \"\" y 0, respectivamente. Ambas definiciones son válidas y no producen conflictos entre sí, ya que los parámetros que esperan son diferentes (ninguno contra un std::string y un unsigned).
Si, por ejemplo, Clase también contuviera un puntero bruto a memoria, podríamos inicializarlo haciendo uso de malloc o free dentro del constructor, sin olvidarse de liberar los recursos solicitados en el destructor, que es lo que veremos a continuación.
Cuando nuestra instancia se sale de scope o ejecutamos delete, el programa llamará al destructor de nuestra clase, el cual se encargará de liberar graciosamente cualquier asignación de memoria que hayamos hecho, además de “saldar cuentas” en nuestra función si es necesario:
class ClaseConDtor {\nprivate:\n std::string str;\npublic:\n ClaseConDtor();\n ~ClaseConDtor(); // Este es nuestro destructor.\n // Un destructor nunca recibe\n // argumentos\n}\n\nif (...) {\n ClaseConDtor a(); // Creamos una instancia\n\n // ...\n}\n// Al momento de abandonar el if, el destructor\n// es llamado automáticamente. El atributo str\n// también invoca al suyo y libera la memoria\n// que utilizaba el string\n\nclass ClaseConDtorMem {\nprivate:\n // ...\npublic:\n ClaseConDtorMem();\n ~ClaseConDtorMem();\n}\n\n// Creamos una instancia en el heap\n// (traten de usar punteros lo menos posible, insisto)\nClaseConDtorMem *c = new ClaseConDtorMem();\n\n// ...\n\ndelete c; // Aquí invocamos al destructor de nuestra\n // clase. Una vez hecho, la memoria que\n // solicitó es devuelta al SOSi su clase no utiliza punteros en bruto, por lo general no va a ser necesario definir un destructor, pues el que entrega el compilador por defecto va a servir en la mayoría de los casos. Como veíamos anteriormente, cualquier instancia de clase que ya tenga definido su propio destructor (como el string de ClaseConDtor) lo va a llamar al momento de invocar el nuestro, lo que nos permite despreocuparnos de ver si el destructor de los atributos fue llamado, pues se hará automáticamente.
Ya que casi todo programa necesita almacenar datos de una forma u otra, se vuelve necesario trabajar con estructuras que los almacenen y nos permitan operar con ellos. Para aplicaciones simples podemos recurrir al clásico arreglo (ya sea de tamaño fijo o variable), pero si nuestros datos ganan complejidad o necesitamos ciertas garantías de tiempo (como adición o lectura en tiempo constante), vamos a tener que utilizar otro tipo de enfoque. El tema es que muchas de las veces estamos reinventando la rueda y no necesitamos realmente crear nuestras propias clases cuando podemos utilizar código hecho por expertos en el tema (a menos que nos estén enseñando cómo funcionan estas estructuras, claro está). Es por esto que les mostraré algunas de estas estructuras que vienen “de fábrica” en cualquier implementación de la librería estándar de C++.
\nstd::vector)Esta es uno de los contenedores más simples de usar y el que más se van a encontrar. std::vector implementa un arreglo de tamaño variable que se encarga de forma automática de agrandar la estructura subyacente que almacena la información:
// Este arreglo es de tamaño fijo. Podemos\n// alterar los números que ya contiene, pero\n// no podemos agregarle ni quitarle celdas.\nint nums[] = {0, 1, 1, 2, 3, 5, 8};\n\nnums[8] = 13; // A menos que quieran que su programa\n // falle o no compile, no hagan esto.#include <iostream>\n\n#include <vector> // Tenemos que incluir esta librería\n // para usar vectores\n\n#include \"persona.h\"\n\n// Como nums2 es un vector, podemos alterar los números\n// que contiene, agregar y eliminar a libertad.\nstd::vector<int> nums2{0, 1, 1, 2, 3, 5, 8};\n\nnums2.push_back(13); // Así agregamos un número al final\nint trece = nums2.pop_back(); // Y así lo eliminamos\n\n// Así podemos obtener el tamaño del vector\nstd::cout << nums2.size() << std::endl;\n\n// Así inicializamos un vector vacío\nstd::vector<Persona> gente;\n\n// Y así podemos construir \"in situ\" una instancia,\n// si es que el tipo es construible. Tan solo tenemos\n// que pasar los mismos parámetros que de costumbre.\ngente.emplace_back(\"Alan Turing\", 41);\n\n// Eso es equivalente a esto:\nPersona alan(\"Alan Turing\", 41);\ngente.push_back(alan);\n\n// Si queremos limpiar el vector, llamamos a clear()\ngente.clear();\n\n// Para comprobar que lo limpiamos, podemos usar\n// el método empty() o chequear que size() == 0\nif (gente.empty()) {\n std::cout << \"Vacío\" << std::endl;\n}\n\n// if (gente.size() == 0) {\n// std::cout << \"Vacío\" << std::endl;\n// }std::list)A diferencia de los vectores, que almacenan su información en un trozo contiguo de memoria que se va moviendo a medida que aumenta el número de elementos que debe almacenar, las listas enlazadas pueden perfectamente estar desperdigadas en la RAM y siguen siendo totalmente accesibles y modificables.
\nUna lista enlazada se compone de nodos, que contienen la información que queremos guardar, y punteros que apuntan al siguiente elemento en la cadena (lista simplemente enlazada) o, incluso, al elemento anterior y siguiente (lista doblemente enlazada):
\n