SoloCodigo

Programación General => C/C++ => Mensaje iniciado por: Rombus en Jueves 9 de Octubre de 2008, 17:48

Título: Asignacion de memoria
Publicado por: Rombus en Jueves 9 de Octubre de 2008, 17:48
Hola!

alguien sabe porque me esta dando un segmentation fault en la linea 16 del siguiente codigo?
uso codeblocks con gcc en ubuntu 8.04

Código: C
  1. typedef struct pila_s{
  2.     void *elementos;
  3.     int size;
  4.     int head;
  5. }pila_t;
  6.  
  7. typedef struct{
  8.     pila_t *pila;
  9.     int sizeTipo;
  10. }pilaAdm_t;
  11.  
  12. pilaAdm_t *stackCreate(int size, int sizeTipo){
  13.     pilaAdm_t *stack = (pilaAdm_t *) malloc (sizeof(pilaAdm_t));
  14.     void *elemens = (void *)malloc(size * sizeTipo);
  15.    
  16.     stack->pila->elementos = elemens;
  17.     stack->pila->size = size;
  18.     stack->pila->head = 0;
  19.     stack->sizeTipo = sizeTipo;
  20.  
  21.     return stack;
  22. }
  23.  

cuando la llamo desde el main lo hago de la siguiente forma:

Código: C
  1. int main(void){
  2.     pilaAdm_t *stack;
  3.     int n = 1;
  4.  
  5.     stack = stackCreate(n,sizeof(int));
  6.     return 0;
  7. }
  8.  
  9.  

espero que alguien me pueda ayudar

gracias!
Título: Re: Asignacion de memoria
Publicado por: Eternal Idol en Jueves 9 de Octubre de 2008, 18:16
stack->pila->elementos = elemens;

El valor de pila es indefinido, esta apuntando generalmente a una direccion erronea.
Título: Re: Asignacion de memoria
Publicado por: Rombus en Jueves 9 de Octubre de 2008, 18:42
:O!

tenes razon!

Código: C
  1. pilaAdm_t *stackCreate(int size, int sizeTipo){
  2.     pilaAdm_t *stack = (pilaAdm_t *) malloc (sizeof(pilaAdm_t));
  3.     pila_t *pilaPmd = (pila_t *) malloc (sizeof(pila_t));
  4.    
  5.     stack->pila = pilaPmd;
  6.     stack->pila->elementos = (void *) malloc (sizeTipo * size);
  7.     stack->pila->size = size;
  8.     stack->pila->head = 0;
  9.     stack->sizeTipo = sizeTipo;
  10.    
  11.     return stack;
  12. }
  13.  

excelente!, gracias Eternal Idol, no lo podia ver

ahora me tira el mismo error pero con las instrucciones de push y pop, pero seguro se deben a algo por el estilo de mi error anterior, ahora las veo.

saludos!
Título: Re: Asignacion de memoria
Publicado por: Eternal Idol en Jueves 9 de Octubre de 2008, 18:49
De nadas, mucha experiencia depurando  :lol:
Título: Re: Asignacion de memoria
Publicado por: Rombus en Jueves 9 de Octubre de 2008, 19:02
jaja ;)

en esta funcion tambien me tira un segmentation fault

Código: C
  1.  
  2. boolean push(pilaAdm_t *stack, void *elemento){
  3.     if(!stack->pila || stackFull(stack->pila))
  4.         return FALSE; //si no hay pila o esta está llena no puedo insertar
  5.  
  6.     memcpy(stack->pila->elementos + (stack->sizeTipo * stack->pila->head++), elemento, stack->sizeTipo);
  7.    
  8.     return TRUE;
  9. }
  10.  
  11.  

en la parte del memcpy, pero no entiendo porque, lo que deberia hacer es copiar elemento, en (posicion 0 de la pila + (size veces por el tipo de dato a guardar)) y el peso del dato a guardar es sizeTipo.

es porque no castiee el stack->pila->elementos de void * a char * y capaz por eso no me permite hacer la aritmetica de punteros?

aunque intente castearlo y tampoco anda :S

saludos!
Título: Re: Asignacion de memoria
Publicado por: Eternal Idol en Jueves 9 de Octubre de 2008, 19:17
Haciendo el casting y llamandolo asi me funciona bien:
Código: Text
  1. push(stack, &n);
  2.  

Fijate que valor se usa como primer parametro a memcpy, deberia ser exactamente stack->pila->elementos.
Título: Re: Asignacion de memoria
Publicado por: Rombus en Jueves 9 de Octubre de 2008, 19:33
esa!

ahi quedó

era ese (basicamente) mi problema, como la invocaba a la funcion no le estaba pasando la direccion de memoria.

aca tengo el codigo para probarlo que quedo andando:

Código: C
  1.  
  2. #include <stdio.h>
  3. /*
  4.  * Servicios de Pila:
  5.  *
  6.  *      pilaAdm_t *stackCreate(int size, int sizeTipo);
  7.  *
  8.  *      void stackDestroy(stack_t *pila);
  9.  *
  10.  *      boolean push(pilaAdm_t *stack, void *elemento);
  11.  *
  12.  *      boolean pop(pilaAdm_t *stack, void *elemento);
  13.  *
  14.  *      stackEmpty(pila);
  15.  *
  16.  *      stackFull(pila);
  17.  *
  18.  */
  19. #ifndef _stdio_h
  20.     #include <stdio.h>
  21. #endif
  22. #ifndef _stdlib_h
  23.     #include <stdlib.h>
  24. #endif
  25. #ifndef _string_h
  26.     #include <string.h>
  27. #endif
  28.  
  29. #ifndef FALSE
  30.     #define FALSE 0
  31. #endif
  32. #ifndef TRUE
  33.     #define TRUE !FALSE
  34. #endif
  35.  
  36. #define stackEmpty(pila)    pila->head == 0
  37. #define stackFull(pila)     pila->head == pila->size
  38.  
  39. typedef char boolean;
  40.  
  41. typedef struct{
  42.     void *elementos;
  43.     int size;
  44.     int head;
  45. }pila_t;
  46.  
  47. typedef struct{
  48.     pila_t *pila;
  49.     int sizeTipo;
  50. }pilaAdm_t;
  51.  
  52. pilaAdm_t *stackCreate(int size, int sizeTipo);
  53. void stackDestroy(pilaAdm_t *pila);
  54. boolean push(pilaAdm_t *stack, void *elemento);
  55. boolean pop(pilaAdm_t *stack, void *elemento);
  56.  
  57. pilaAdm_t *stackCreate(int size, int sizeTipo){
  58.     pilaAdm_t *stack = (pilaAdm_t *) malloc (sizeof(pilaAdm_t));
  59.  
  60.     stack->pila = (pila_t *) malloc (sizeof(pila_t));
  61.     stack->pila->elementos = (void *) malloc (sizeTipo * size);
  62.     stack->pila->size = size;
  63.     stack->pila->head = 0;
  64.     stack->sizeTipo = sizeTipo;
  65.  
  66.     return stack;
  67. }
  68. void stackDestroy(pilaAdm_t *stack){
  69.     free(stack->pila->elementos);
  70.     free(stack);
  71. }
  72. boolean push(pilaAdm_t *stack, void *elemento){
  73.     if(!stack->pila || stackFull(stack->pila))
  74.         return FALSE; //si no hay pila o esta esta llena no puedo insertar
  75.  
  76.     memcpy((char *)stack->pila->elementos + (stack->sizeTipo * stack->pila->head++), elemento,stack->sizeTipo);
  77.  
  78.     return TRUE;
  79. }
  80. boolean pop(pilaAdm_t *stack, void *elemento){
  81.     if(!stack->pila || stackEmpty(stack->pila))
  82.         return FALSE;   //Si no tengo pila, o si esta vacia no puedo hacer pop
  83.  
  84.     stack->pila->head--;
  85.     //memcpy(elemento, (void *)(((char *)stack->pila->elementos) + (stack->sizeTipo * stack->pila->head)), stack->sizeTipo);
  86.     memcpy(elemento, stack->pila->elementos + (stack->sizeTipo * stack->pila->head), stack->sizeTipo);
  87.  
  88.     return TRUE;
  89. }
  90.  
  91.  
  92.  
  93. int main(void){
  94.     pilaAdm_t *stack;
  95.     int i,a, n = 5;
  96.  
  97.     stack = stackCreate(n,sizeof(int));
  98.  
  99.     for(i=0; i< 5; i++)
  100.         push(stack,(void *)&i);
  101.  
  102.     for(i=0; i<5; i++){
  103.         pop(stack,(void *)&a);
  104.         printf("%dn",a);
  105.     }
  106.     return 0;
  107. }
  108.  
  109.  

mi idea es meterlo en un archivo stack.c asi lo puedo incluir en mis programas :D


muchas gracias Eternal idol, no hay nada peor que bloquearse con algo y no poder salir de ahi!