int * sin signo volátil * const

En la siguiente línea de código, ¿cuál es el propósito de las palabras clave const ?

 volatile unsigned int * const UART0DR = (unsigned int *)0x10009000; 

Entiendo el bit volatile unsigned int * , pero ¿por qué hay const ?

const y volatile se llaman “calificadores de tipo”. Su syntax es una de las cosas más confusas de C.

En primer lugar tenemos el caso con una variable ordinaria. Por lo general, escribe el calificador de tipo antes del nombre de la variable: const int x; , pero también está bien escribirlo después del nombre de la variable: int const x; . El significado es el mismo, la última syntax está ahí para confundir.

Al declarar un puntero, le interesan dos tipos: el tipo del puntero en sí y el tipo al que apunta. Con los punteros comunes, esto es trivial: int* x significa que el tipo de puntero es puntero a int, y el apuntado a tipo es int.

Si el apuntado al tipo es const int, el puntero se declara como const int* x . El puntero es de tipo puntero a const-int, y el tipo apuntado a es int int. Si desea confundir a todos, también puede escribir int const* x , es equivalente.

Digamos que queremos que el puntero en sí sea constante también. Por alguna razón queremos bloquear al progtwigdor para que no cambie la dirección a la que se apunta. Por ejemplo, tal vez el puntero se almacene en la memoria de solo lectura de un sistema integrado. Un puntero constante a los datos, se declara como int*const x; con la palabra clave const después de la *. El apuntado a tipo en este caso es int , y no const int . (Intento escribir la constante junto con el *, sin espacio entre ellas, para enfatizar que el puntero es constante)

Si queremos que el apuntado al tipo también sea constante, tendríamos que combinar las dos declaraciones anteriores: const int*const x; significa un puntero constante que apunta a una constante int.

 const int x; // x is a constant data variable int const x; // x is a constant data variable const int* x; // x is a non-constant pointer to constant data int const* x; // x is a non-constant pointer to constant data int*const x; // x is a constant pointer to non-constant data const int*const x; // x is a constant pointer to constant data 

En los ejemplos anteriores he usado el const tipo de const . ¡Pero volatile también es un calificador de tipo, y se comporta exactamente de la misma manera! Es posible declarar punteros no volátiles a datos volátiles, etc.

Y finalmente, es posible combinar diferentes calificadores de tipo. Por ejemplo, un volatile const int* es un puntero no constante, no volátil a datos const constantes volátiles. Una vez más, tenemos la maravillosa opción de mezclar el orden de estos para confundir, por lo que también podemos escribir volatile int const * o int volatile const * etc y todo significa lo mismo.

Entiendo el bit volatile unsigned int * , pero ¿por qué hay const ?

Significa que el puntero es constante, lo que significa que el puntero no puede (más bien no debería) apuntar a otra dirección.

Tenga en cuenta lo siguiente, construye:

 volatile unsigned int * const UART0DR = 

El puntero es constante aquí.


 volatile unsigned int const * UART0DR = 

La dirección señalada es constante aquí.


 volatile unsigned int const * const UART0DR = 

La dirección señalada y el puntero son constantes en este caso.

De http://cdecl.org

 volatile unsigned int *const a => declare a as const pointer to volatile unsigned int