El fin de semana con Alexander y Manzillo participamos en la ACM-ICPC Chile representando a la UTFSM con el nombre de “The Overloaded Operators”, un alias gracias a nuestro coach Bonva, y nos fue bien. Sacamos 3º lugar nacional, lo cual no es malo si solo tuvimos tres entrenamientos (resolvimos tres problemas) antes de la competencia, esto porque recién a finales de Septiembre decidimos participar y nos contactamos con Bonva, quién finalmente terminó siendo nuestro coach.

El scoreboard final muestra que la cosa estuvo bien peleada, aunque lo cierto es que al primer lugar ya no lo alcanzabamos y el segundo lugar tenía ya el globo del segundo problema cuando nosotros decidimos hacerlo, y afortunadamente fuimos los más rápidos y nos quedamos con el tercer lugar.

Los problemas eran dificiles y ahí se noto nuestra falta de preparación, ya que nos habíamos especializado en programación dinámica, teoría de grafos y backtracking, dejando gran cantidad de temas sin tocar. Igual el input de prueba de los problemas era muy básico y el juez retornaba respuestas malas con lo cual estuvimos un poco perdidos en un tercer problema que funcionaba pero el juez lo declaraba malo, y otro problema que funcionaba con el input, pero después al llegar a la casa de un amigo me puso un caso y he ahí el error.

Sin duda fue una buena experiencia, sacamos buenos frutos de una casi nula preparación y nos la craneamos harto. El próximo año ya no podré concursar por el tema de los años límite, pero Manzillo y Ale quedaron con sed de gloria y andan en busca del tercer integrante, que de preferencia sea una biblia de programación + mente brillante.

Pronto terminaré con Behemoth y algunas otras cosas.

Saludos y gracias a todos por el apoyo

El enlace aquí.

Pronto estaré escribiendo más, terminar con Behemoth y tratar sobre otras cosas.

Saludos!

Al parecer renovaron el staff y han sacado el cuarto número, como siempre en portugués. Portuguesinho se parece harto al español así que no encuentro problemas para entender los artículos, espero ustedes tampoco. Se ve interesante el de los telefónos públicos y la ingeniería inversa en aplicaciones Java. Solo espero que este semestre terminé luego para tener algo de tiempo libre y poder leer y escribir más a menudo.

El enlace aquí.

Esto parece ser parte de una sección en Google Code llamada “Let’s make the web faster“, que tiene otros artículos sobre optimización de código web.

El artículo sobre PHP aquí.

Desde 1985, por y para hackers. Phrack 66 disponible.

[c]
funcion(puntero)
{
puntero = malloc(…)
for(…)
puntero[i] = i;
}

inicio()
{
int *ptr;
funcion(ptr);
printf(ptr[i]);
}
[/c]

Le sugerí que pasará el puntero por referencia (&ptr), probé el código para el primer elemento del nuevo arreglo y funcionó. Después me dijo que no funcionaba para el segundo elemento y todos los demás. Y ahí se cayó el mundo. El código era el siguiente :

[c]
#include
#include

void modify(int **temp)
{
int i;
*temp = malloc(4*3);
for(i = 0; i < 3; i++)
*temp[i] = i;
}
int main()
{
int *arreglo;
modify(&arreglo);
printf(“%d %d %d\n”, arreglo[0] ,arreglo[1], arreglo[2]);
}
[/c]

Este código, yo creía que perfecto, lanzaba este output.

$ ./malloc
0 0 0

Ante la duda, consulte en uno de los canales de IRC que frecuento, y les presente el problema y en un minuto me dijeron la solución : ” en vez de *temp[i] = i, usa (*temp)[i] = i . El operador ( ) tiene mayor precedencia que []“. Cambie esa línea y funcionó altiro, pero me costo entender un poco la solución.

Explicación

Todo se trata de la precedencia de operadores en C. Revisando cualquier tabla, tal como en esta página, vemos que () tiene mayor precedencia que [], y más abajo sale *. En resumen, () > [] > *. Ahora vamos a entender un poco de lo teórico y terminamos con lo práctico.

Al inicio, con *temp[i], lo que se produce es lo siguiente. Con i=0, *temp[0] = *(*temp), con lo cual se evalua (*temp) y luego el puntero a esa evaluación se le asigna 0, lo cual es correcto y por eso funciono cuando probé con solo un elemento. Pero después con el segundo elemento, el output tira 0 siendo que debería ser 1.

Por qué? Porque el operador [] tiene mayor precedencia que el operador de indirección *, con lo cual primero se evalua temp[i], y luego se desreferencia, con lo cual muestra elementos cercanos a la variable temp y no a lo que apunta *temp. Si bien temp es un puntero al puntero arreglo, ésta tiene una dirección propia (&temp).

Por el contrario, si usamos (*temp)[i], primero se desreferencia el puntero *temp, y luego se mueve el offset i desde la direccion a la que apunta *temp.

Este código pretende dejar más claro el uso de los operadores en las variables:

[c] #include
#include

void modify(int **temp)
{
int i;
*temp = malloc(4*3);

printf(“temp @ %p\n”, &temp);
printf(“temp apunta a @ %p\n”, *temp);

printf(“\nMetodo *temp[i]:\n”);
for(i = 0; i < 3; i++)
printf(“*temp[%d] : %p\n”, i, temp[i]);

printf(“\nMetodo (*temp)[i]\n”);
for(i = 0; i < 3; i++)
{
printf(“(*temp)[%d] : %p\n”, i, &(*temp)[i]);
(*temp)[i] = i;
}
}
int main()
{
int *arreglo;
modify(&arreglo);
printf(“\nRetornando en main()\n”);
printf(“arreglo[0] @ %p = %d\n”, &arreglo[0], arreglo[0]);
printf(“arreglo[1] @ %p = %d\n”, &arreglo[1], arreglo[1]);
printf(“arreglo[2] @ %p = %d\n”, &arreglo[2], arreglo[2]);
}
[/c]
El output de este programa es :

$ ./malloc-exp
temp @ 0xbfd7b870
temp apunta a @ 0x95ac008

Metodo *temp[i]:
*temp[0] : 0x95ac008
*temp[1] : 0xbfd7b8b0
*temp[2] : 0xbfd7b908

Metodo (*temp)[i]
(*temp)[0] : 0x95ac008
(*temp)[1] : 0x95ac00c
(*temp)[2] : 0x95ac010

Retornando en main()
arreglo[0] @ 0x95ac008 = 0
arreglo[1] @ 0x95ac00c = 1
arreglo[2] @ 0x95ac010 = 2

Ahora espero quede más clara la cosa. Si usamos *temp[i], para el primer elemento funciona (como lo vi antes), pero desde el segundo elemento las direcciones que toma son cercanas a la dirección de la variable temp (0xbfd7b870) y en offset mayores a los que supone la variable i (4 bytes). Al parecer esta tomando memoria que no está asignada. En cambio con (*temp)[i], todas las direcciones están juntas, tal como corresponde en un arreglo, separadas por 4 bytes que corresponde al tamaño de un entero.

Después de vuelta en main(), vemos que el arreglo apunta a las direcciones malloc-eadas anteriormente, y podemos acceder a los valores que antes fijamos.

Espero que este post sea de ayuda cuando tengan un problema de este tipo, es un poco difícil de explicar en keywords, pero bueno ya está. Una buena lección sobre operadores.

Saludos