Calificador constante en C

El calificador const se puede aplicar a la declaración de cualquier variable para especificar que su valor no cambiará (que depende de dónde se almacenan las variables const, podemos cambiar el valor de la variable const usando el puntero). El resultado está definido por la implementación si se intenta cambiar una const. 
1) Puntero a variable. 
 

int *ptr;

Podemos cambiar el valor de ptr y también podemos cambiar el valor del objeto al que apunta ptr. El puntero y el valor apuntado por el puntero se almacenan en el área de lectura y escritura. Consulte el siguiente fragmento de código.
 

#include <stdio.h>
int main(void)
{
    int i = 10;
    int j = 20;
    int *ptr = &i;
    /* pointer to integer */
    printf("*ptr: %d\n", *ptr);
  
    /* pointer is pointing to another variable */
    ptr = &j;
    printf("*ptr: %d\n", *ptr);
  
    /* we can change value stored by pointer */
    *ptr = 100;
    printf("*ptr: %d\n", *ptr);
  
    return 0;
}

Producción: 
 

    *ptr: 10
    *ptr: 20
    *ptr: 100

2) Puntero a constante.  
El puntero a constante se puede declarar de las siguientes dos maneras.
 

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) apuntado usando el puntero ptr. El puntero se almacena en el área de lectura-escritura (pila en el presente caso). El objeto apuntado puede estar en el área de solo lectura o de lectura y escritura. Veamos los siguientes ejemplos.
 

#include <stdio.h>
int main(void)
{
    int i = 10;  
    int j = 20;
    /* ptr is pointer to constant */
    const int *ptr = &i;   
  
    printf("ptr: %d\n", *ptr);
    /* error: object pointed cannot be modified
    using the pointer ptr */   
    *ptr = 100;
  
    ptr = &j;          /* valid */
    printf("ptr: %d\n", *ptr);
  
    return 0;
}

Producción: 
 

 error: assignment of read-only location ‘*ptr’

El siguiente es otro ejemplo donde la variable i en sí misma es constante.
 

#include <stdio.h>
 
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\n", *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\n", *ptr);
 
    return 0;
}

Producción: 
 

 error: assignment of read-only location ‘*ptr’

La calificación hacia abajo no está permitida en C++ y puede causar advertencias en C. A continuación se muestra otro ejemplo con calificación hacia abajo.
 

#include <stdio.h>
 
int main(void)
{
    int i = 10;
    int const j = 20;
 
    /* ptr is pointing an integer object */
    int *ptr = &i;
 
    printf("*ptr: %d\n", *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\n", *ptr);
 
    return 0;
}
 
// Reference:
// http://www.dansaks.com/articles/1999-02%20const%20T%20vs%20T%20const.pdf
 
// More interesting stuff on C/C++ @ http://www.dansaks.com/articles.shtml

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 apuntado por el puntero, pero no podemos cambiar el puntero para que apunte a otra variable. 
 

#include <stdio.h>
  
int main(void)
{
   int i = 10;
   int j = 20;
/* constant pointer to integer */
   int *const ptr = &i;   
  
   printf("ptr: %d\n", *ptr);
  
   *ptr = 100;    /* valid */
   printf("ptr: %d\n", *ptr);
  
   ptr = &j;        /* error */
   return 0;
}

Producción: 
 

 error: assignment of read-only variable ‘ptr’

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, así como tampoco podemos apuntar el puntero a otras variables. Veamos con un ejemplo. 
 

#include <stdio.h>
  
int main(void)
{
    int i = 10;
    int j = 20;
/* constant pointer to constant integer */
    const int *const ptr = &i;       
  
    printf("ptr: %d\n", *ptr);
  
    ptr = &j;     /* error */
    *ptr = 100;   /* error */
  
    return 0;
}

Producción: 
 

     error: assignment of read-only variable ‘ptr’
     error: assignment of read-only location ‘*ptr’

Resumen : 

Este artículo está compilado por “ Narendra Kangralkar ”. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.