La palabra clave const en la función Declaración de clases en C++

1. la palabra clave const en la función Declaración de clases en C++
2. el comportamiento de una función miembro en C++
3. el Comportamiento de una Función Miembro const en C++
4. Conclusión

En C++, la palabra clave const define aquellos valores que no cambiarán y permanecerán constantes durante la ejecución del programa. Esto suena bastante simple para las variables y los datos que contienen.

Pero, ¿cómo se puede declarar constante una función y qué se debe mantener sin cambios en una función? Responderemos a todas estas preguntas y muchas más en este artículo, ¡así que sigue leyendo!

Tenga en cuenta que las funciones que estamos viendo aquí son las que pertenecen a una clase, es decir, funciones miembro.

la palabra clave const en la función Declaración de clases en C++

Antes de sumergirnos en la discusión real, comprendamos correctamente la declaración del problema.

Ya sabemos que una clase puede tener miembros de datos y funciones miembro. Estas funciones miembro generalmente se declaran dentro de la clase de la siguiente manera:

class Demo  // class
{
 public:
  int x;
  int showDemo();  // member function declaration
}

Aquí, la función miembro showDemo() pertenece a la clase Demo. Pero, ¿qué significa si agregamos const al final de la función miembro de esta manera?

class Demo  // class
{
 public:
  int x;
  int showDemo() const;  // const member function declaration
}

Primero veamos cómo se comporta normalmente una función miembro en C++ para entender esto.

el comportamiento de una función miembro en C++

Mira el código que se muestra a continuación. Aquí, primero definimos una clase llamada Demo con un miembro de datos, chocolates, cuyo valor se establece en 2,, y una función miembro, Desert().

Dentro de la función miembro, junto con una declaración de bienvenida, imprimimos el valor original del miembro de datos, chocolates, y luego incrementamos este valor en uno. Además, imprimimos el valor incrementado de chocolates en la siguiente instrucción.

Finalmente, creamos un objeto, demo, y llamamos a la función miembro Desert() desde el bloque main. Además, imprimimos el valor de chocolates usando el objeto demo y el operador punto.

#include <iostream>
using namespace std;

class Demo {
 public:
  int chocolates = 2;

 public:
  void Desert()  // member function
  {
    cout << "Hello Chocolates" << endl;
    cout << "Before change: " << chocolates << endl;
    chocolates++;
    cout << "After change: " << chocolates << endl;
  }
};

int main() {
  Demo demo;
  demo.Desert();
  cout << demo.chocolates << endl;
}

Producción :

Hello Chocolates
Before change: 2
After change: 3
3

Puede ver que aquí, cambiamos el valor del miembro de datos, chocolates, desde dentro de la función miembro. Para enfatizar el cambio con mayor precisión, también imprimimos el valor de esta variable desde el bloque principal, pero aún obtenemos el valor actualizado, que es 3.

Por lo tanto, este ejemplo implica que de alguna manera podemos usar una función miembro normal para cambiar el objeto.

Aquí, solo tenemos una clase y un objeto. Sin embargo, al trabajar con muchas clases y objetos, hay muchas posibilidades de que se realicen cambios accidentalmente en un objeto.

Para evitar esto, usamos la función miembro const de C++.

el Comportamiento de una Función Miembro const en C++

Mira el ejemplo que se da a continuación. Este código es el mismo que el anterior, excepto que esta vez ponemos la palabra clave const después de la función miembro.

#include <iostream>
using namespace std;

class Demo {
 public:
  int chocolates = 2;

 public:
  void Desert() const  // const member function
  {
    cout << "Hello Chocolates" << endl;
    cout << "Before change: " << chocolates << endl;
    chocolates++;
    cout << "After change: " << chocolates << endl;
  }
};

int main() {
  Demo demo;
  demo.Desert();
  cout << demo.chocolates << endl;
}

Producción :

In member function 'void Demo::Desert() const':
error: increment of member 'Demo::chocolates' in read-only object
   13 |             chocolates++;
      |             ^~~~~~~~~~

Puede ver cómo cambia la salida haciendo que la función miembro sea constante. Esta vez, el valor de chocolates no se incrementa y obtenemos un error.

Este ejemplo implica que no podemos usar una función miembro const para cambiar el objeto de ninguna manera.

Mediante las dos comparaciones anteriores de funciones miembro, concluimos que el uso de const en tales declaraciones de funciones implica que no habrá ningún cambio en ningún miembro de la clase. Cuando agregamos const a un método, el puntero this apunta al objeto const y, por lo tanto, no podemos cambiar ningún miembro de datos.

Después de todo lo que hemos aprendido, podemos decir que usamos las funciones miembro const para evitar cambiar un objeto. Pero entonces, podrías preguntarte: ¿para qué sirve un objeto const?

Cuando declaramos un objeto como const, solo puede invocar las funciones miembro const. Esto se debe a que un objeto const no se puede modificar, y esta no alteración solo la prometen las funciones miembro const.

Mira el ejemplo de abajo.

Dentro de la clase Desierto, tenemos dos funciones miembro, desierto() y desierto() const. Luego, dentro del bloque principal, definimos dos objetos, d, y un objeto constante, dd.

Tenga en cuenta algunos puntos importantes sobre este ejemplo:

1. Tenemos dos funciones miembro con el mismo nombre. La única diferencia es que una de ellas es una función miembro const.
2. Tenemos dos objetos, uno de los cuales es un objeto constante.
3. Llamamos a la función miembro desierto() desde ambos objetos sin especificar qué objeto llama a qué función.

#include <iostream>
using namespace std;

class Desert {
 private:
  int cakes;

 public:
  void desert() { cout << "The first desert function." << endl; }

  void desert() const  // the const member function
  {
    cout << "The second const desert function." << endl;
  }
};

int main() {
  Desert d;              // object of class
  const Desert& dd = d;  // constant object of class
  d.desert();
  dd.desert();
}

Producción :

The first desert function.
The second const desert function.

El resultado muestra claramente que la función miembro normal, desert(), fue llamada automáticamente por el objeto normal, d. Mientras que la función miembro const, desert() const, es invocada automáticamente por el objeto const, dd.

La salida cambiará si eliminamos la palabra clave const del objeto.

int main() {
  Desert d;        // object of class
  Desert& dd = d;  // remove the constant keyword
  d.desert();
  dd.desert();
}

Producción :

The first desert function.
The first desert function.

Esta vez ambos objetos llaman a la primera función. Esto prueba que un objeto const invoca una función miembro const.

Tenga en cuenta que esto no significa que no podamos llamar a una función miembro const en un objeto no constante. Sin embargo, una función que no sea const solo puede ser llamada por objetos que no sean const.

Hasta aquí todo bien, pero hay un caso excepcional. Si usamos el cuantificador mutable con cualquier miembro de datos de la clase, podemos modificar el objeto incluso en un método const.

Mira este ejemplo.

#include <iostream>
using namespace std;

class Demo {
 public:
  mutable int chocolates = 2;  // mutable quantifier
 public:
  void Desert() const  // const member function
  {
    cout << "Hello Chocolates" << endl;
    cout << "Before change: " << chocolates << endl;
    chocolates++;
    cout << "After change: " << chocolates << endl;
  }
};

int main() {
  Demo demo;
  demo.Desert();
  cout << demo.chocolates << endl;
}

Producción :

Hello Chocolates
Before change: 2
After change: 3
3

Ahora, esta vez, no obtenemos un error como antes porque estamos usando el cuantificador mutable con el miembro de datos chocolates. Esto suele ser útil si queremos contar el número de veces que se llama a un método.

Se trata de una función miembro const en C++. Cuanto más juegues con los ejemplos, haciendo pequeños cambios aquí y allá, ¡más claridad obtendrás!

Para saber más sobre const en C++, consulte esta documentación.

Conclusión

En este artículo, discutimos los conceptos de funciones miembro const de C++. Una función miembro const asegura que un objeto no se modifique accidentalmente, y podemos usarla con objetos const y no const.

Sin embargo, un objeto const solo puede revocar una función miembro const. Además, usar la palabra clave mutable con los miembros de datos puede cambiar el comportamiento habitual de la función de miembro const y generalmente se usa para fines de conteo.