En lenguaje ensamblador normalmente no tenemos que preocuparnos demasiado por la distinción entre punteros y números enteros. Algunas instrucciones generan direcciones mientras que otras se comportan aritméticamente, pero debajo hay un único tipo de datos: bitvectors. En cambio, los lenguajes de alto nivel no ofrecen oportunidades para confundir punteros y enteros ya que las abstracciones separan por completo el uno del otro. Además, un lenguaje de alto nivel puede elegir no exponer nada relacionado con punteros.
Comentarios
¿-e+pu?
Porque si los confundes sale esto
el maravilloso mundo del aliasing y las optimizaciones del compilador
#4
En la noticia está. Pero básicamente lo que hace es analizar el origen de la variable que se modifica. Al utilizar una constante para modificar el valor de un puntero GCC previene que dicha modificación tenga un efecto no deseado evitando convertirlo en un sinónimo.
En el ejemplo tienes el puntero «x» y el puntero «p». GCC previene el sinónimo de p = x si para establecer el valor de p utilizas una constante que te has sacado de la manga en vez de calcularla en base al origen de las variables:
* Cálculo en base a origen de variables de tipo puntero:
uintptr_t xi = (uintptr_t)x;
uintptr_t yi = (uintptr_t)y;
uintptr_t diff = xi - yi;
printf("diff = %ldn", (long)diff);
int *p = (int *)(yi + diff);
* Cálculo con valor sacado de la manga:
uintptr_t xi = (uintptr_t)x;
uintptr_t yi = (uintptr_t)y;
uintptr_t diff = xi - yi;
printf("diff = %ldn", (long)diff);
int *p = (int *)(yi - 96); //
A mí personalmente me parece que lo que hace GCC es mejor. Evita que el programador la cague.
#3 ¿Qué hace GCC?
Un putero