una - ¿Cuál es el significado de void*volatile*en c++

volatile c++

Question

Estoy mirando el siguiente código:

inline void* interlocked_read_acquire(void* volatile* x);

y me pregunto por qué no solo un volatile void* como argumento. En general, ¿cuál es la semántica o definición de un volatile* ? También estoy asumiendo que usted podría usar el calificador volatile* con cualquier otro tipo además del nulo. ¿Es eso correcto?

Answer 1

preguntándose por qué [ void* volatile* y] no solo un volatile void* ...?

Son cosas diferentes.

• void* volatile* es un puntero a un volatile ( void* ) (por lo tanto, la eliminación de referencias y el acceso al volatile void* son posibles sin lanzar, pero solo le daría la dirección de alguna cosa aún no especificada en la memoria)

• volatile void* es un puntero a un void volátil (por lo que debe convertir a un tipo como, por ejemplo, volatile int* o volatile My_Class* antes de la desreferenciación)

Answer 2

Use cdecl o la regla de las agujas del reloj para descifrar las declaraciones de estilo C:

void* volatile* x

• declara x como puntero a puntero volátil a vacío

que es diferente de:

volatile void* x

• declarar x como puntero a void volátil

Answer 3

volatile es una propiedad complementaria, primero puede eliminarla para leerla

void* volatile* x

a:

void* *x

Esto es muy familiar. Por ejemplo, una matriz de punteros de memoria malloc-ed. Y no te confundirás con

volatile void*

que se reduce a

void* x.

Answer 4

void * ptr1; significa que ptr1 es una variable cuyo tipo es void * . Este tipo indica un "puntero genérico": apunta a alguna ubicación de memoria pero no contiene información de tipo de lo que hay en esa ubicación.

void * volatile ptr2; significa que la variable ptr2 también es un puntero genérico, pero ptr2 también es volatile . La palabra clave volatile se denomina calificador de cv y tiene las mismas reglas gramaticales que const .

El significado de una variable volátil es que cuando algún otro código dice ptr2 , el compilador no puede optimizar eso; debe leer o escribir la ubicación de la memoria donde se almacena ptr2 ; debe permitir la posibilidad de que algún proceso externo también esté leyendo o escribiendo esa ubicación.

Finalmente, void * volatile *x es algo que puede apuntar a ptr2 . Por ejemplo, podríamos tener void * volatile * x = &ptr2; . Si luego escribimos *x = NULL; por ejemplo, entonces *x tiene el tipo void * volatile que tiene las mismas implicaciones que acabamos de ver para ptr2 .

El compilador se quejaría si omite el calificador, por ejemplo, void * *y = &ptr2; . Esto se debe a que la expresión *y luego tendría el tipo void * (no volátil), por lo que el compilador podría realizar optimizaciones a su alrededor, sin embargo, este es un comportamiento incorrecto porque ptr2 no permite esas optimizaciones. (Es posible que reconozca que la "corrección de volátiles" es el mismo tipo de corrección de constantes).