En este artículo, las diversas funciones del palabra clave constante que se encuentra en C++ son discutidos. Cuando sea palabra clave constante se adjunta con cualquier método(), variable, variable de puntero , y con el objeto de una clase impide que específica objeto/método()/variable para modificar el valor de sus elementos de datos.

Variables constantes:

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

• El variable constante 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 debía 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  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 constante sin asignar un valor explícito, se genera un error en tiempo de compilación (CTE).

operador condicional en java

Palabra clave constante con variables de puntero:

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

Cuando el variable de 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  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.

De lo contrario , el Aparecerá el siguiente error: Si intentamos modificar el valor de la variable const.

Cuando la variable de puntero constante 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  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; }>

10 and D 0x7ffe21db72b4 and D>

Explicación: Los valores que se almacenan en las variables de puntero correspondientes 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 son modificables.

'algoritmo bancario'

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 enfrentaremos al error.

Cuando el puntero constante apunta a una variable constante :

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  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 de puntero constante apunta a la variable constante. Entonces, no puedes cambiar la constante. variable de puntero(*P) ni el valor almacenado en la ubicación señalada por ese variable de puntero (*P).

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

Pasar el valor del argumento constante a un parámetro no constante de una función causa un error : Pasar un valor de argumento constante a un parámetro no constante de una función no es válido y genera 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  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; }>

Producción: El error en tiempo de compilación que aparecerá como si el valor constante se pasara a cualquier argumento no constante de la función, aparecerá el siguiente error en tiempo de compilación:

Además, pasar el puntero constante no generará ningún error porque se crea otro puntero que también apunta a la misma ubicación de memoria.

//C++ program to demonstrate the above concept #include  using namespace std; void printfunc(int* ptr) {  cout << 'Value :' << *ptr << endl;  cout << 'Address of ptr :' << &ptr << endl; } //Driver Code int main() {  int x = 10;  int* const i = &x;  printfunc(i);  cout << 'Address of i :' << &i << endl; }>

Value :10 Address of ptr :0x7ffff0189b48 Address of i :0x7ffff0189b70>

El código se ejecuta sin errores y los dos punteros tienen direcciones diferentes.

sitios como bedpage

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 int constante, por lo que este es un puntero a un valor constante.

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

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

Métodos constantes:

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

Sintaxis:

const Class_Name Object_name;>

• Cuando una función se declara como constante, se puede invocar en cualquier tipo de objeto, tanto en objetos constantes como en objetos no constantes.
• Siempre que un objeto se declara como constante, es necesario inicializarlo en el momento de la declaración. Sin embargo, la inicialización del objeto durante la declaración sólo es posible con la ayuda de constructores.

Hay dos maneras de una función constante declaración:

Declaración ordinaria de función constante :

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

Una función miembro constante 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  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 10 12>

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

Parámetros de función constante y tipo de retorno :

Parámetros de una función() y El tipo de retorno de función() se puede declarar como constante. Los valores constantes no se pueden cambiar ya que cualquier intento de este tipo 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  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 << '
' << 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 si se utiliza la declaración y = 6 en la función foo():

java es nulo

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

Para 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  using namespace std; const int foo(int y) {  y--;  return y; } int main() {  int x = 9;  const int z = 10;  cout << foo(x) << '
' << foo(z);  return 0; }>

8 9>

El valor devuelto será un valor constante.

Además, no existe ningún problema sustancial al pasar una variable constante o no constante a la función siempre que la pasemos por valor porque se crea una nueva copia. El problema surge cuando intentamos pasar la variable constante por referencia a la función cuyo parámetro no es constante. Esto ignora el calificador constante, lo que genera el siguiente error:

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

// C++ program for the above approach #include  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) << '
' << foo(z);  return 0; }>

9 10>

Explicación: Aquí, se pueden pasar valores constantes y no constantes como parámetro constante a la función, pero no podemos 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á un error en tiempo de compilación ya que y es const var y su valor no se puede cambiar.