58 - Métodos constantes (const)

Otra parte más donde podemos utilizar la palabra clave "const" es al final de la declaración de un método.

Cuando implementamos un método y sabemos que no modificará en ningún momento atributos de la clase lo más conveniente es hacerlo explícito agregando la palabra "const" luego del nombre del método.

Veamos el mismo problema que hicimos cuando vimos parámetros constantes, pero ahora agreguemos también los métodos que conviene que sean constantes y cuales son sus beneficios.

Problema 1:

Plantear una clase ListaGenerica con los métodos insertarPrimero, imprimir y un método llamado iguales que le llegue como parámetro la referencia de otra lista y retorne true o false. Definir el parámetro del método iguales de tipo const. Especificar que los métodos imprimir e iguales son constantes.

Programa:

#include <iostream>

using namespace std;

class ListaGenerica {
private:
    class Nodo {
    public:
        int info;
        Nodo *sig;
    };
    Nodo *raiz;
public:
    ListaGenerica();
    ~ListaGenerica();
    void insertarPrimero(int x);
    void imprimir() const;
    bool iguales(const ListaGenerica *lista2) const;
};

ListaGenerica::ListaGenerica()
{
    raiz = NULL;
}

ListaGenerica::~ListaGenerica()
{
    Nodo *reco = raiz;
    Nodo *bor;
    while (reco != NULL)
    {
        bor = reco;
        reco = reco->sig;
        delete bor;
    }
}

void ListaGenerica::insertarPrimero(int x)
{
    Nodo *nuevo = new Nodo();
    nuevo->info = x;
    nuevo->sig = raiz;
    raiz = nuevo;
}

void ListaGenerica::imprimir() const
{
    Nodo *reco = raiz;
    cout << "Listado completo.\n";
    while (reco != NULL)
    {
        cout << reco->info << "-";
        reco = reco->sig;
    }
    cout << "\n";
}

bool ListaGenerica::iguales(const ListaGenerica *lista2) const
{
    bool iguales = true;
    Nodo *reco1 = raiz;
    Nodo *reco2 = lista2->raiz;
    while (reco1 != NULL && reco2 != NULL)
    {
        if (reco1->info != reco2->info)
        {
            iguales = false;
            break; //salimos del while
        }
        reco1 = reco1->sig;
        reco2 = reco2->sig;
    }
    if (iguales == true && reco1 == NULL && reco2 == NULL)
        return true;
    else
        return false;
}

int main()
{
    ListaGenerica *lg1 = new ListaGenerica();
    lg1->insertarPrimero(10);
    lg1->insertarPrimero(20);
    lg1->insertarPrimero(30);
    lg1->imprimir();

    ListaGenerica *lg2 = new ListaGenerica();
    lg2->insertarPrimero(10);
    lg2->insertarPrimero(20);
    lg2->insertarPrimero(30);
    lg2->imprimir();

    if (lg1->iguales(lg2))
        cout << "Las dos listas son iguales\n";
    else
        cout << "Las dos listas no son iguales\n";

    delete lg1;
    delete lg2;
    return 0;
}

Este proyecto lo puede descargar en un zip desde este enlace : MetodosConstantes1.zip

Para declarar que los métodos imprimir e iguales son constantes le agregamos al final la palabra clave "const":

class ListaGenerica {
private:
    class Nodo {
    public:
        int info;
        Nodo *sig;
    };
    Nodo *raiz;
public:
    ListaGenerica();
    ~ListaGenerica();
    void insertarPrimero(int x);
    void imprimir() const;
    bool iguales(const ListaGenerica *lista2) const;
};

Lo mismo cuando implementamos el método debemos agregarle la palabra clave "const":

void ListaGenerica::imprimir() const
{
    Nodo *reco = raiz;
    cout << "Listado completo.\n";
    while (reco != NULL)
    {
        cout << reco->info << "-";
        reco = reco->sig;
    }
    cout << "\n";
}

La definición de métodos constantes nos evita introducir errores de modificación de atributos como por ejemplo de modificar raiz en el método imprimir (el compilador nos avisa que no podemos modificar raiz):

void ListaGenerica::imprimir() const
{
    raiz = NULL;
    Nodo *reco = raiz;
    cout << "Listado completo.\n";
    while (reco != NULL)
    {
        cout << reco->info << "-";
        reco = reco->sig;
    }
    cout << "\n";
}

Como vemos los parámetros constantes y los métodos constantes nos permiten dejar más claro y seguro el código en cuanto a que pueden modificar. Ahora el método iguales en nuestro problema no puede modificar ni la lista que llega ni la lista propiamente dicha del objeto actual:

bool ListaGenerica::iguales(const ListaGenerica *lista2) const
{
    bool iguales = true;
    Nodo *reco1 = raiz;
    Nodo *reco2 = lista2->raiz;
    while (reco1 != NULL && reco2 != NULL)
    {
        if (reco1->info != reco2->info)
        {
            iguales = false;
            break; //salimos del while
        }
        reco1 = reco1->sig;
        reco2 = reco2->sig;
    }
    if (iguales == true && reco1 == NULL && reco2 == NULL)
        return true;
    else
        return false;
}

Cualquiera de estos dos intentos de modificar raiz genera un error sintáctico cuando lo compilamos:

    raiz=NULL;
    lista2->raiz=NULL;

Es importante hacer notar que el constructor y el destructor no pueden ser constantes. Casi siempre en un constructor inicializamos atributos y en el destructor liberamos espacio.

En nuestro problema el método insertarPrimero no debe ser constante ya que modificamos el puntero raiz para que apunte al nodo que creamos en dicho método.

Retornar