Palabra clave constante en C++

En este artículo, se analizan las diversas funciones de la palabra clave const que se encuentra en C++ . Cada vez que la palabra clave const se adjunta con cualquier método(), variable, variable de puntero y con el objeto de una clase, evita que ese objeto/método()/variable específico modifique el valor de sus elementos de datos.

Variables constantes :

Hay un cierto conjunto de reglas para la declaración e inicialización de las variables constantes:

• La variable const no se puede dejar sin inicializar en el momento de la asignación.
• No se le puede asignar valor en ninguna parte del programa.
• Se necesitaba proporcionar un valor explícito a la variable constante en el momento de la declaración de la variable constante.

A continuación se muestra el programa C++ para demostrar el concepto anterior:

// C++ program to demonstrate the
// the above concept
#include <iostream>
using namespace std;
 
// Driver Code
int main()
{
 
    // const int x;  CTE error
    // x = 9;   CTE error
    const int y = 10;
    cout << y;
 
    return 0;
}

10

El error al que se enfrenta la declaración defectuosa : si intenta inicializar la variable const sin asignar un valor explícito, se genera un error de tiempo de compilación (CTE). 

Palabra clave const con variables de puntero :

 Los punteros se pueden declarar con una palabra clave const. Entonces, hay tres formas posibles de usar una palabra clave const con un puntero, que son las siguientes:

Cuando la variable del puntero apunta a un valor constante :

Sintaxis: 

const data_type* var_name;

A continuación se muestra el programa C++ para implementar el concepto anterior: 

// C++ program to demonstrate the
// above concept
#include <iostream>
using namespace std;
 
// Driver Code
int main()
{
    int x{ 10 };
    char y{ 'M' };
 
    const int* i = &x;
    const char* j = &y;
 
    // Value of x and y can be altered,
    // they are not constant variables
    x = 9;
    y = 'A';
 
    // Change of constant values because,
    // i and j are pointing to const-int
    // & const-char type value
    // *i = 6;
    // *j = 7;
 
    cout << *i << " " << *j;
}

9 A

Explicación: aquí, en el caso anterior, i y j son dos variables de puntero que apuntan a una ubicación de memoria const int-type y char-type, pero el valor almacenado en estas ubicaciones correspondientes se puede cambiar como lo hemos hecho anteriormente. 

En caso contrario , aparecerá el siguiente error: Si intentamos modificar el valor de la variable const.

Cuando la variable de puntero const apunta al valor :

Sintaxis:

data_type* const var_name;

A continuación se muestra el ejemplo para demostrar el concepto anterior:

// C++ program to demonstrate the
// above concept
#include <iostream>
using namespace std;
 
// Driver Code
int main()
{
    // x and z non-const var
    int x = 5;
    int z = 6;
 
    // y and p non-const var
    char y = 'A';
    char p = 'C';
 
    // const pointer(i) pointing
    // to the var x's location
    int* const i = &x;
 
    // const pointer(j) pointing
    // to the var y's location
    char* const j = &y;
 
 
    // The values that is stored at the memory location can modified
    // even if we modify it through the pointer itself
    // No CTE error
    *i = 10;
    *j = 'D';
 
    // CTE because pointer variable
    // is const type so the address
    // pointed by the pointer variables
    // can't be changed
    // *i = &z;
    // *j = &p;
 
    cout << *i << " and " << *j
        << endl;
    cout << i << " and " << j;
 
    return 0;
}

Output:
10 and D
0x7ffe7b2392a0 and DC

Explicación: los valores que se almacenan en la variable de puntero correspondiente i y j son modificables, pero las ubicaciones que señalan las variables de puntero constante donde se almacenan los valores correspondientes de x e y no se pueden modificar. 

De lo contrario, aparecerá el siguiente error: Las variables de puntero son constantes y apuntan a las ubicaciones donde se almacenan x e y. Si intentamos cambiar la ubicación de la dirección, nos encontraremos con el error.

Cuando el puntero const apunta a una variable const :

Sintaxis:

const data_type* const var_name;

A continuación se muestra el programa C++ para demostrar el concepto anterior:

// C++ program to demonstrate
// the above concept
#include <iostream>
using namespace std;
 
// Driver code
int main()
{
    int x{ 9 };
 
    const int* const i = &x;
   
    // *i=10;  
    // The above statement will give CTE
    // Once Ptr(*i) value is
    // assigned, later it can't
    // be modified(Error)
 
    char y{ 'A' };
 
    const char* const j = &y;
   
    // *j='B';
    // The above statement will give CTE
    // Once Ptr(*j) value is
    // assigned, later it can't
    // be modified(Error)
 
    cout << *i << " and " << *j;
 
    return 0;
}

9 and A

Explicación: Aquí, la variable puntero const apunta a la variable const. Por lo tanto, no puede cambiar la variable de puntero const (*P) ni el valor almacenado en la ubicación señalada por esa variable de puntero (*P).

De lo contrario, aparecerá el siguiente error: Aquí tanto la variable puntero como las ubicaciones apuntadas por la variable puntero son constantes, por lo que si se modifica alguna de ellas, aparecerá el siguiente error:

Pasar el valor del argumento const a un parámetro no const de una función causa un error : pasar el valor del argumento const a un parámetro no const de una función no es válido, le da un error en tiempo de compilación.

A continuación se muestra el programa C++ para demostrar el concepto anterior:

// C++ program to demonstrate
// the above concept
#include <iostream>
using namespace std;
 
int foo(int* y)
{
    return *y;
}
 
// Driver code
int main()
{
    int z = 8;
    const int* x = &z;
    cout << foo(x);
    return 0;
}

Salida: el error en tiempo de compilación que aparecerá como si el valor const se pasara a cualquier argumento que no sea const de la función, luego aparecerá el siguiente error en tiempo de compilación:

En pocas palabras, la discusión anterior se puede concluir de la siguiente manera:

1. valor int = 5; // valor no constante

2. const int *ptr_1 = &valor; // ptr_1 apunta a un valor «const int», por lo que este es un puntero a un valor const.

3. int *const ptr_2 = &valor; // ptr_2 apunta a un «int», por lo que este es un puntero constante a un valor no constante.

4. const int *const ptr_3 = &value; // ptr_3 apunta a un valor «const int», por lo que este es un puntero const a un valor const.

Métodos constantes :

Al igual que las funciones miembro y los argumentos de función miembro, los objetos de una clase también se pueden declarar como const . Un objeto declarado como const no se puede modificar y, por lo tanto, solo puede invocar funciones miembro const, ya que estas funciones garantizan que no se modifique el objeto.

Sintaxis:

const Class_Name Object_name;

• Cuando una función se declara como const, se puede llamar a cualquier tipo de objeto, tanto a objetos const como a objetos que no son const.
• Cada vez que un objeto se declara como const, debe inicializarse en el momento de la declaración. Sin embargo, la inicialización del objeto durante la declaración solo es posible con la ayuda de constructores.

Hay dos formas de declarar una función constante :

Declaración ordinaria de la función constante :

const void foo()
{
   //void foo() const Not valid
}      
int main()
{
   foo(x);
}  

Una función miembro const de la clase :

class
{
   void foo() const
   {
       //.....
   }
}

A continuación se muestra el ejemplo de una función constante:

// C++ program to demonstrate the
// constant function
#include <iostream>
using namespace std;
 
// Class Test
class Test {
    int value;
 
public:
    // Constructor
    Test(int v = 0)
    {
        value = v;
    }
 
    // We get compiler error if we
    // add a line like "value = 100;"
    // in this function.
    int getValue() const
    {
        return value;
    }
     
    // a nonconst function trying to modify value
    void setValue(int val) {
        value = val;
    }
};
 
// Driver Code
int main()
{
    // Object of the class T
    Test t(20);
 
    // non-const object invoking const function, no error
    cout << t.getValue() << endl;
     
    // const object
      const Test t_const(10);
   
    // const object invoking const function, no error
    cout << t_const.getValue() << endl;
   
    // const object invoking non-const function, CTE
    // t_const.setValue(15);
     
    // non-const object invoking non-const function, no error
    t.setValue(12);
     
    cout << t.getValue() << endl;
 
    return 0;
}

20

El siguiente error aparecerá si intenta llamar a la función no constante desde un objeto constante

Parámetros de funciones constantes y tipo de retorno :

Los parámetros de una función() y el tipo de retorno de la función() se pueden declarar como constantes. Los valores constantes no se pueden cambiar ya que cualquier intento generará un error en tiempo de compilación.

A continuación se muestra el programa C++ para implementar el enfoque anterior: 

// C++ program to demonstrate the
// above approach
#include <iostream>
using namespace std;
 
// Function foo() with variable
// const int
void foo(const int y)
{
    // y = 6; const value
    // can't be change
    cout << y;
}
 
// Function foo() with variable int
void foo1(int y)
{
    // Non-const value can be change
    y = 5;
    cout << '\n'
         << y;
}
 
// Driver Code
int main()
{
    int x = 9;
    const int z = 10;
   
    foo(z);
    foo1(x);
 
    return 0;
}

10
5

 Explicación: Se mostrará el siguiente error: 

• // y = 6; un valor constante no se puede cambiar ni modificar.

Para el tipo de retorno constante : el tipo de retorno de la función() es constante y, por lo tanto, nos devuelve un valor entero constante. A continuación se muestra el programa C++ para implementar el enfoque anterior: 

// C++ program for the above approach
#include <iostream>
using namespace std;
 
const int foo(int y)
{
    y--;
    return y;
}
 
int main()
{
    int x = 9;
    const int z = 10;
    cout << foo(x) << '\n'
         << foo(z);
 
    return 0;
}

8
9

No hay problema sustancial para pasar la variable const o non-const a la función porque el valor que devolverá la función será constante automáticamente. Como el argumento de la función no es const.

Para el tipo de retorno constante y el parámetro constante : aquí, tanto el tipo de retorno como el parámetro de la función son de tipo constante. A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program for the above approach
#include <iostream>
using namespace std;
 
const int foo(const int y)
{
    // y = 9; it'll give CTE error as
    // y is const var its value can't
    // be change
    return y;
}
 
// Driver code
int main()
{
    int x = 9;
    const int z = 10;
    cout << foo(x) << '\n'
         << foo(z);
 
    return 0;
}

9
10

Explicación: aquí, tanto los valores constantes como los no constantes se pueden pasar como parámetro constante a la función, pero no se nos permite cambiar el valor de una variable pasada porque el parámetro es constante. De lo contrario, nos enfrentaremos al error de la siguiente manera: 

// y=9; dará el error de tiempo de compilación ya que y es const var, su valor no se puede cambiar.