El calificador constante se puede aplicar a la declaración de cualquier variable para especificar que su valor no se cambiará (lo que depende de dónde se almacenan las variables constantes, podemos cambiar el valor de la variable constante usando un puntero). El resultado está definido por la implementación si se intenta cambiar una constante.
Usar el calificador const en C es una buena práctica cuando queremos asegurarnos de que algunos valores permanezcan constantes y no se modifiquen accidentalmente.
saltar lista
En programación C, el calificador const se puede utilizar en diferentes contextos para proporcionar diversos comportamientos. A continuación se muestran algunos casos de uso diferentes del calificador const en C:
1. Variables constantes
const int var = 100;>
En este caso, const se usa para declarar una variable. era como una constante con un valor inicial de 100. El valor de esta variable no se puede modificar una vez inicializada. Vea el siguiente ejemplo:
C
// C program to demonstrate that constant variables can not> // be modified> #include> int> main()> {> >const> int> var = 100;> >// Compilation error: assignment of read-only variable> >// 'var'> >var = 200;> >return> 0;> }> |
>
>
Producción
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Puntero a constante
const int* ptr;>
O
int const *ptr;>
Podemos cambiar el puntero para que apunte a cualquier otra variable entera, pero no podemos cambiar el valor del objeto (entidad) al que apunta usando el puntero ptr. El puntero se almacena en el área de lectura y escritura (pila en el presente caso). El objeto señalado puede estar en el área de solo lectura o lectura-escritura. Veamos los siguientes ejemplos.
Ejemplo 1:
C
ordenar lista de matrices java
// C program to demonstrate that the pointer to point to> // any other integer variable, but the value of the object> // (entity) pointed can not be changed> #include> int> main(>void>)> {> >int> i = 10;> >int> j = 20;> >/* ptr is pointer to constant */> >const> int>* ptr = &i;> >printf>(>'ptr: %d
'>, *ptr);> >/* error: object pointed cannot be modified> >using the pointer ptr */> >*ptr = 100;> >ptr = &j;>/* valid */> >printf>(>'ptr: %d
'>, *ptr);> >return> 0;> }> |
>
>
Producción
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Ejemplo 2: Programa donde la variable i en sí misma es constante.
C
: en java
// C program to demonstrate that the pointer to point to> // any other integer variable, but the value of the object> // (entity) pointed can not be changed> #include> int> main(>void>)> {> >/* i is stored in read only area*/> >int> const> i = 10;> >int> j = 20;> >/* pointer to integer constant. Here i> >is of type 'const int', and &i is of> >type 'const int *'. And p is of type> >'const int', types are matching no issue */> >int> const>* ptr = &i;> >printf>(>'ptr: %d
'>, *ptr);> >/* error */> >*ptr = 100;> >/* valid. We call it up qualification. In> >C/C++, the type of 'int *' is allowed to up> >qualify to the type 'const int *'. The type of> >&j is 'int *' and is implicitly up qualified by> >the compiler to 'const int *' */> >ptr = &j;> >printf>(>'ptr: %d
'>, *ptr);> >return> 0;> }> |
>
>
Producción
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Calificación baja no está permitido en C++ y puede causar advertencias en C. La calificación baja se refiere a la situación en la que un tipo calificado se asigna a un tipo no calificado.
Ejemplo 3: Programa para mostrar la calificación.
C
// C program to demonstrate the down qualification> #include> int> main(>void>)> {> >int> i = 10;> >int> const> j = 20;> >/* ptr is pointing an integer object */> >int>* ptr = &i;> >printf>(>'*ptr: %d
'>, *ptr);> >/* The below assignment is invalid in C++, results in> >error In C, the compiler *may* throw a warning, but> >casting is implicitly allowed */> >ptr = &j;> >/* In C++, it is called 'down qualification'. The type> >of expression &j is 'const int *' and the type of ptr> >is 'int *'. The assignment 'ptr = &j' causes to> >implicitly remove const-ness from the expression &j.> >C++ being more type restrictive, will not allow> >implicit down qualification. However, C++ allows> >implicit up qualification. The reason being, const> >qualified identifiers are bound to be placed in> >read-only memory (but not always). If C++ allows> >above kind of assignment (ptr = &j), we can use 'ptr'> >to modify value of j which is in read-only memory.> >The consequences are implementation dependent, the> >program may fail> >at runtime. So strict type checking helps clean code.> >*/> >printf>(>'*ptr: %d
'>, *ptr);> >return> 0;> }> |
>
>
Ciclo de vida del desarrollo de programas
Producción
main.c: In function ‘main’: main.c:16:9: warning: assignment discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers] 16 | ptr = &j; | ^ *ptr: 10 *ptr: 20>
3. Puntero constante a variable
int* const ptr;>
La declaración anterior es un puntero constante a una variable entera, lo que significa que podemos cambiar el valor del objeto señalado por el puntero, pero no podemos cambiar el puntero para que apunte a otra variable.
Ejemplo
C
// C program to demonstrate that the value of object pointed> // by pointer can be changed but the pointer can not point> // to another variable> #include> int> main(>void>)> {> >int> i = 10;> >int> j = 20;> >/* constant pointer to integer */> >int>*>const> ptr = &i;> >printf>(>'ptr: %d
'>, *ptr);> >*ptr = 100;>/* valid */> >printf>(>'ptr: %d
'>, *ptr);> >ptr = &j;>/* error */> >return> 0;> }> |
>
>
Producción
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Puntero constante a constante
const int* const ptr;>
La declaración anterior es un puntero constante a una variable constante, lo que significa que no podemos cambiar el valor señalado por el puntero ni tampoco podemos apuntar el puntero a otras variables. Veamos con un ejemplo.
C
// C program to demonstrate that value pointed by the> // pointer can not be changed as well as we cannot point the> // pointer to other variables> #include> int> main(>void>)> {> >int> i = 10;> >int> j = 20;> >/* constant pointer to constant integer */> >const> int>*>const> ptr = &i;> >printf>(>'ptr: %d
'>, *ptr);> >ptr = &j;>/* error */> >*ptr = 100;>/* error */> >return> 0;> }> |
>
cadena en java
>
Producción
./Solution.c: In function 'main': ./Solution.c:12:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^ ./Solution.c:13:10: error: assignment of read-only location '*ptr' *ptr = 100; /* error */ ^>
Ventajas de los calificadores constantes en C
El calificador constante en C tiene las siguientes ventajas:
- Legibilidad de código mejorada: al marcar una variable como constante, indica a otros programadores que su valor no debe cambiarse, lo que hace que su código sea más fácil de entender y mantener. Seguridad de tipos mejorada: al usar const, puede asegurarse de que los valores no se modifiquen accidentalmente, lo que reduce la posibilidad de errores en su código. Optimización mejorada: los compiladores pueden optimizar las variables constantes de manera más efectiva, ya que saben que sus valores no cambiarán durante la ejecución del programa. Esto puede dar como resultado un código más rápido y eficiente. Mejor uso de la memoria: al declarar las variables como constantes, a menudo puede evitar tener que hacer una copia de sus valores, lo que puede reducir el uso de la memoria y mejorar el rendimiento. Compatibilidad mejorada: al declarar variables como constantes, puede hacer que su código sea más compatible con otras bibliotecas y API que usan variables constantes. Confiabilidad mejorada: al usar const, puede hacer que su código sea más confiable, ya que puede garantizar que los valores no se modifiquen inesperadamente, lo que reduce el riesgo de errores en su código.
Resumen
| Tipo | Declaración | Cambio de valor del puntero (*ptr = 100) | Cambio de valor señalador (ptr = &a) |
|---|---|---|---|
| Puntero a variable | int*ptr | Sí | Sí |
| Puntero a constante | constante int * ptr int constante * ptr | No | Sí |
| Puntero constante a variable | int * constante ptr | Sí | No |
| Puntero constante a constante | constante int * constante ptr | No | No |
Este artículo está compilado por Narendra Kangralkar .