Mensajes

Tu enunciado lía mucho. Antes de empezar debes estructurarlo, sino será imposible llegar a una solución.
Define otra vez el problema. Muchas veces preguntándose correctamente le pregunta, la respuesta llega sola.

Tiene razón, **dx es una errata, seguramente el ejercicio quería decir **ddx.

Prueba el siguiente programa:

Código (c) [Seleccionar] Expandir

#include <stdio.h>

void bits(double n) {
    for(int b = sizeof(double) * 8 - 1; b >= 0 ; --b) {
        printf("%lu", *(long unsigned*)&n >> b & 1);
    }
}

int main() {
    printf("\n\n%.25lf\n", 0.1);
    bits(0.1);
   
    printf("\n\n%.25lf\n", 5.);
    bits(5);
   
    printf("\n\n%.25lf\n", 25.);
    bits(25);
}

Como puedes ver no hay pérdida de precisión. En cambio si la hay en 0.1, que pasado a binario IEEE754:

Código [Seleccionar] Expandir

0011111110111001100110011001100110011001100110011001100110011010

Como se puede ver hay una periodicidad que tiende a infinito.

Es muy raro. Tanto 5 como 25 tiene una cantidad muy baja de bits como para que se pierda información.

Si tu compilador es gcc o g++ puedes ver el archivo generado, con las macros expandidas si compilas con la opción -E. Para verlo con tranquilidad lleva llévalo a un archivo:

Código [Seleccionar] Expandir

gcc -E fuente.c > expandido.c
sinedo fuente.c el nombre de tu archivo fuente.

En principio las macros solo se escriben en una única línea pero se usa la barra invertida para indicar al preprocesador que ésta continua en la linea siguiente.

Los datos de los parámetros se pasan literalmente: lo que tu escribas en el parámetro de llamada es lo mismo que va a usar la macro en su conversión.

Las llaves también aparecen en el código final cuando la macro se expande.

Las macros tienen el operado # y ## que convierte en cadena el parámetro y convierte en cadena dos parámetros y los une respectivamente. Se pueden hacer cosas muy interesantes con eso.

Para intercambiar dos valores, sin tener que usar una variable auxiliar puedes usar.
A ^= B;
B ^= A;
A ^= B;

Entiendo, aunque voy a decir que no es una técnica que me gusta mucho. Veo una fuga de memoria si el puntero es a un array dinámico y no se libera la memoria al final del programa (para sistemas donde el kernel no libere la memoria dinámica del programa cuándo este termine).


Edito:
Una solución es usando un array estático, así el programa limpia la memoria con normalidad. Por contra se debe pensar bien la cantidad de memoria a usar de antemano.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>


char * itoa(int num) {
   static char retval[12];
   size_t size;
   int negativo = num < 0;
   unsigned n = (unsigned)abs(num);
   
   size = (n? log10(n) : 0) + 1 + negativo;
   
   if(negativo)
       retval[0] = '-';
   
   retval[size--] = '\0';
       
   do {
       retval[size--] = n%10 + '0';
       n /= 10;
   } while(n);
   
   return retval;
}

int main() {
   printf("%s\n", itoa(INT_MAX));
   printf("%s\n", itoa(0));
   printf("%s\n", itoa(INT_MIN));
}

Vale, pues entonces ahora mismo no entiendo qué es lo que se pretende.

A ver un ejemplo.

Partiendo de tu sistema de referencia (arriba a la izquierda, abajo a la izquierda) posiciónate sobre la casilla de inicio de tu figura y a partir de ella recorre las casillas de tu tablero que ocuparía la figura.

Por ejemplo. Tomando la casilla [0,0] la de arriba a la izquierda.

Código [Seleccionar] Expandir


OOOOO
O#OOO
O#OOO
O#OOO
O###O

Tu figura empezaría en la casilla [1,1] y ocuparía [2,1], [3,1], [4,1], [4,2], [4,3].
Tu figura tendrá la información de que casillas ocupa de forma relativa o cuántas, como quieras hacerlo. Usando ese dato y sumado a la casilla de inicio de la figura sabrás qué ocupa de forma global.

Espero haberme explicado bien.

Vale, eso son los puntos de secuencia.

Un punto de secuencia marca cuándo una instrucción se ha completado y no va a haber efectos secundarios en posteriores procesos.

Como has dicho el operador de asignación ( = ) no marca un punto de secuencia por lo que el compilador puede elegir arbitrariamente que parte del igual quiere resolver primero. Si es la parte izquierda no pasará nada, se dereferenciará la dirección de la variable a[i] y después pasará a la parte derecha para calcular el valor que debe asignar, por lo que el postincremento no afectará. Pero si primero decide evaluar la parte derecha para saber qué valor debe asignar, al evaluar la parte izquierda i habrá aumentado por el postincremento.

Si buscas más información sobre efectos secundarios y puntos de secuencia (sequence points) verás que la historia es bastante complicada. Basta con que te quedes que no hay que mezclar según que expresiones en una instrucción.