Regla en el sentido de las agujas del reloj/Espiral en C/C++ con ejemplos

El Método Espiral/En el sentido de las agujas del reloj es una herramienta mágica para que los programadores de C/C++ definan el significado de la declaración de sintaxis en la cabeza en cuestión de segundos. Este método fue creado por David Anderson y aquí hay un breve resumen sobre cómo aplicar este método.

Mientras codifica, cuando alguien se encuentra con una nueva declaración de sintaxis no deseada:

string(const** f(int, void (*const p)(int)))(char[]);

La pregunta que surge aquí es ¿cuál es el significado del nombre de función «f»? Hay una forma infame que ayudará a deducir el significado de esta función «f» en segundos.

Acercarse:

Paso 1: Considere esta espiral en el sentido de las agujas del reloj.

Paso 2: Reemplace O con un .

Paso 3: ahora, en el sentido de las agujas del reloj, reemplace «|» con algunas palabras e intente obtener el significado de la sintaxis, y reemplace «|» con “(“. Los corchetes explican su función y dicen “’a’ es una función”. 

Paso 4: Considere ver qué hay dentro de la función/corchetes redondos, de modo que se encuentren los corchetes abiertos (recuerde que, por la precedencia de los operadores , los corchetes siempre se abren primero) y vaya de izquierda a derecha hasta el final de los corchetes «)». . ‘a’ es una función con el entero ‘x’ como argumento”.

Paso 5: ahora regrese al primer paréntesis y continúe la ruta en espiral desde «(«. Reemplace «|» con «*». Esto significa un valor de retorno y un puntero . Aquí «‘a’ es una función con el número entero ‘ x’ como argumento que devuelve un puntero a “.

Paso 6: continúa la espiral en el sentido de las agujas del reloj. Uno encontrará «int» que ya se trató, así que continúe el camino en espiral.

Paso 7: Reemplace «|» con «int». Se puede decir que “’a’ es una función con el entero ‘x’ como argumento que devuelve un puntero a un entero”.

Paso 8: Nuevamente, continúa este camino y obtendrás «;» lo que significa que este es el final de la declaración, y vea que así es como el significado de la sintaxis se puede definir fácilmente.

Finalmente, se puede decir que “’a’ es una función con un entero ‘x’ como argumento que devuelve un puntero al entero”.

Respuesta: f es una función con argumentos como int y pa funciona con el argumento como int, devolviendo un puntero constante a nada (void) devolviendo un puntero a un puntero a una función constante con la array de caracteres como argumento devolviendo una string .

Puntos importantes:

1. Explicaciones de sintaxis:
   • A[ ]: la array A tiene un tamaño indefinido y A[ 5 ] significa que el tamaño de la array es 5.
   • (tipo 1,tipo 2): función que pasa tipo1 y tipo2.
   • *: puntero a.
2. Comience con el nombre de la variable.
3. Mantenga esta lectura hasta que se sobrescriban todos los modificadores en la declaración de la variable.
4. Siempre complete primero cualquier contenido entre paréntesis.
5. Continúe haciendo esto en una espiral/dirección de las manecillas del reloj hasta que todas las fichas hayan sido cubiertas.

Ejemplo:
Considere un ejemplo visualizando una espiral en el cerebro:

(char const *p) ( int , const (int  *)*);

Recuerda la regla del pulgar. Siempre comience con el nombre de una variable. A partir de una espiral variable en el sentido de las agujas del reloj.

Paso 1: ‘p’ es la variable.

p                                              

Paso 2: ‘p’ es una variable a la que apunta.

p -> *                                     

Paso 3: ‘p’ es una variable que apunta a una función.

p -> *  -> (                             

Paso 4: ‘ p’ es una variable que apunta a una función con int como argumento.

p -> *  -> (  -> int               

Paso 5: Para el siguiente paso, no hay nombre de variable, así que dé uno. Que sea ‘a’. Entonces la expresión se puede escribir como:

(char const *p) ( int , const (int  *)* a );

Paso 6: Aquí ‘a’ es una variable. 

a     

Paso 7: El corchete redondo cerrado no dice nada, así que continúa.

a-> )                          

Paso 8: En el siguiente paso, a es un puntero de variable a.

a -> ) -> *      

Paso 9: ignore el punto y coma porque la definición de sintaxis no está completa, así que continúe.

a -> ) -> *  -> ;  

Paso 10: El paréntesis redondo cerrado no dice nada, así que continúa.

a -> ) -> *  -> ; -> )

Paso 11: Ahora ‘a’ es una variable puntero a puntero.

a -> ) -> *  -> ; -> ) -> *                                                                      

Paso 12: ‘a’ es un puntero variable al puntero int.

a -> ) -> *  -> ; -> ) -> * -> int                     

Paso 13: ‘a’ es un puntero variable a puntero int constante.

a -> ) -> *  -> ; -> ) -> * -> int -> const     

Volvamos a donde quedó la definición de ‘p’.

Paso 14: ‘p’ es una variable que apunta a una función con int como argumento y una variable apunta a la constante de puntero int que devuelve una constante.

p -> *  -> (  -> int , const... -> const

Nota: 
Los términos reutilizados que ya se usaron para definir la sintaxis se ignoran aquí.

Paso 15: p es una variable que es un puntero a una función con int como argumento y un puntero de variable a puntero int constante que devuelve un carácter constante.

p -> *  -> (  -> int , const... -> const->char

Esto termina el significado completo de la sintaxis.

Nota:
Hay una excepción a esta regla cuando la sintaxis tiene arrays (especialmente arrays multidimensionales ), por lo que hay una actualización de esta regla.

• Cuando encuentre una array, muévase al corchete de cierre más a la derecha y trate la array como un ‘barrido’ «
• Ejemplo: 
  • int *a[10][]: ‘a’ es una array multidimensional de tamaño 10 y un tamaño indefinido de punteros a int.