SoloCodigo

Pues entonces comprueba el valor de los registros involucrados. Como tampoco dices sobre qué arquitectura estás trabajando, no te puedo ser más específico.

estoy trabajando con UBUNTU 9.04, en una portatil HP pavilion dv6000

Entonces es arquitectura x86 (Intel)

personalmente no se cual es la diferencia entre esas memorias.....

http://en.wikipedia.org/wiki/Dynamic_memory_allocation
http://en.wikipedia.org/wiki/Stack_(data_structure)

Para comprobar valores de pila y montón

Me salen los siguientes errores en la compilación:

junior@JuNioR-Linux:~/Escritorio/Calidad$ gcc -g memoria.c -o memoria
memoria.c: En la función ‘valor_monticulo’:
memoria.c:13: aviso: la asignación crea un puntero desde un entero sin una conversión
memoria.c:15: aviso: declaración implícita incompatible de la función interna ‘free’
memoria.c: En la función ‘main’:
memoria.c:21: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’
memoria.c:22: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’
junior@JuNioR-Linux:~/Escritorio/Calidad$ gcc -g memoria.c -o memoria
memoria.c: En la función ‘valor_monticulo’:
memoria.c:12: aviso: declaración implícita incompatible de la función interna ‘malloc’
memoria.c:14: aviso: declaración implícita incompatible de la función interna ‘free’
memoria.c: En la función ‘main’:
memoria.c:20: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’
memoria.c:21: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’

Al código q me mandaste solo le he aumentado esta linea: #include <stdio.h> .
Que podrá ser, no??
Gracias por tu atención.
Saludos.

Acabo de agregarle una libreria... #include <stdlib.h>... el coódigo esta de la siguiente manera:

#include <stdio.h>
#include <stdlib.h>
 int valor_pila()
 {
     __asm__("push %espnt"
             "pop %eax");
 }
 
 int valor_monticulo()
  {
      int *p, valor;
     
      p = malloc(sizeof(int));
      valor = (int) p;
      free(p);
      return valor;
  }
   
  int main(int argc, char *argv[])
  {
      printf("Valor de la pila: %pn", valor_pila());
      printf("Valor del monticulo: %pn", valor_monticulo());
      system("PAUSE");
      return 0;
  }

Luego de compilarlo, ya solo me salen los siguientes errores ó mensajes:

junior@JuNioR-Linux:~/Escritorio/Calidad$ gcc -g memoria.c -o memoria
memoria.c: En la función ‘main’:
memoria.c:21: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’
memoria.c:22: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’

Saludos.

Acaba de compilar sin ningun problema con una pequeñisima modificación.....adjunto la solución definitiva..

El programita hace lo que necesito, pero no lo entiendo el código , asi que me pondré a descifrarlo por que tengo que explicarle a mi profe como lo hice.

Te estoy infinitamente agradecido, muchisimas gracias por tu atención y tu paciencia!....ojalá hubieran mas personas como vos, el mundo sería mejor!!

Saludos.      

Usa las etiquetas de código, colega...

Suponía que no entendrías esto  

Hay que tener en cuenta que el código en C primero se pasa a ensamblador y posteriormente se ensambla y enlaza. Si quieres ver el código en ensamblador correspondiente, usa el modificador -S con gcc. Con la función __asm__() lo que estamos diciéndole al compilador de C es que no compile la cadena que vaya dentro de ella, sino que simplemente la pase tal cual al ensamblador. Con ello ejecutamos código en ensamblador desde C.

Luego hay que entender ciertos aspectos internos de las CPU Intel. Éstas usan un registro llamado ESP para apuntar al elemento más alto de la pila. Ésta función devuelve el valor de ese registro (puedes ver %esp). También existe el registro EAX, que es dónde las funciones guardan el valor de retorno. Por ejemplo, cuando haces return 0;, en realidad la CPU pone un cero en el registro EAX antes de volver de la función.

Por tanto nuestro código en ensamblador es:

La instrucción push inserta un elemento en la pila y la instrucción pop saca un elemento de la pila. Estas instrucciones se encargan internamente de cargar/salvar el valor de/en la pila en el registro correspondiente y modificar ESP para que apunte al siguiente valor. Entonces metemos el valor del registro ESP en la pila y luego sacamos ese mismo valor en EAX, así ya lo tenemos incluso como valor de retorno, así que finalizamos directamente la función.

Para los curiosos: no hemos hecho

porque la instrucción mov en los procesadores x86 no acepta un registro de segmento como operando. Así que tenemos que recurrir al truco de la pila.