[C] - Creazione di un piccolo stack

[Michele Facchin]

Salve, ho scritto questo codice in C, e non riesco a capire perchè una volta eseguito il processo mi dice "Segmentation fault", qualcuno sà dirmi dove sbaglio?

Il risultato in teoria dovrebbe essere 30, ma non capisco esattamente dove stia l'errore, (credo nel pop).

Grazie

#include <stdio.h>
#include <stdlib.h>
 
struct dato {
   int elemento;
   struct dato * punt;
};

void create (struct dato *);
void push (struct dato *, int);
void pop (struct dato *, int *);

int main () {
   int a;
   struct dato * s1;

   create (s1);

   push (s1, 10);
   push (s1, 20);
   push (s1, 30);

   pop (s1, &a);
   printf ("%d \n", a);

   return (0);
}

void create (struct dato * s) {
   s = NULL;
}

void push (struct dato * s, int d) {
   struct dato * p = (struct dato *) malloc (sizeof (struct dato));
   p -> elemento = d;
   p -> punt = s;
   s = p;
}

void pop (struct dato * s, int * d) {
   struct dato * p = s;
   * d = s -> elemento;
   s = s -> punt;
   free (p);
}

[Grunt]

void pop (struct dato * s, int * d) {
   struct dato * p = s;
   d=malloc(sizeof(int));
   * d = s -> elemento;
   s = s -> punt;
   free (p);
}

Hai dimenticato di allocare il puntatore!!! Prova un po'!!!

[r0x]

Questo codice non fa nulla, agisce sul parametro formale s, non sul parametro attuale:

void create (struct dato * s) {
   s = NULL;
}

Fai cosi`:

void create( struct dato** s )
{
    *s = NULL;
}

Stesso discorso qui:

void push (struct dato * s, int d) {
   struct dato * p = (struct dato *) malloc (sizeof (struct dato));
   p -> elemento = d;
   p -> punt = s;
   s = p;
}

void push( struct dato** s, int d )
{
    struct dato* p = ( struct dato* ) malloc( sizeof( struct dato ) );
    p->elemento = d;
    p->punt = *s;
    *s = p;
}

E qui:

void pop (struct dato * s, int * d) {
   struct dato * p = s;
   * d = s -> elemento;
   s = s -> punt;
   free (p);
}

void pop( struct dato** s, int* d )
{
    struct dato* p = *s;
    *d = ( *s )->elemento;
    *s = ( *s )->punt;
    free( p );
}

Ovviamente modifica le chiamate in modo opportuno.

(C`era un errore )

[lelefante]

L'errore grosso sta nella push, perche' tu modifichi un puntatore locale alla funzione, fuori da essa la modifica viene persa. Per farlo come vuoi fare tu dovresti passare l'indirizzo di quel puntatore, e quindi modificarlo tramite esso.
Prova a dare un'occhiata a questa versione... visto che anche io sono abbastanza indietro con il C sono ber gradite critiche/suggerimenti, ecc...

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

struct dato {
   int elemento;
   struct dato * punt;
};

struct stack
{
	struct dato * last;
};

struct stack * create(struct stack **);
void push (struct stack *, int);
struct dato * pop (struct stack *);
void destroy (struct stack *);

int main () {
	int a;
	struct stack * s1;
	struct dato * d;

	create (&s1);

	push (s1, 10);
	push (s1, 20);
	push (s1, 30);

	d = pop (s1);
	while(d) {
		a = d -> elemento;
		printf ("%d \n", a);
		free(d);
		d = pop (s1);
	}
	destroy(s1);
   	return (0);
}

struct stack * create (struct stack ** s)
{
	*s = (struct stack *) malloc (sizeof (struct stack));
 	if(*s)
  	{
		(*s) -> last = NULL;
  	}
  	return *s;
}

void push (struct stack * s, int n) {
	struct dato * d = (struct dato *) malloc (sizeof (struct dato));
 	if(d)
  	{
		d -> punt = s -> last;
		d -> elemento = n;
		s -> last = d;
	}
}

struct dato * pop (struct stack * s) {
	struct dato * tmp = s -> last;
	if(tmp)
	{
		s -> last = s -> last -> punt;
	}
	return tmp;
}

void destroy (struct stack * s)
{
	if(s == NULL) return;

	while(s -> last)
	{
		struct dato * tmp = s -> last;
		if(tmp)
		{
			s -> last = s -> last -> punt;
			free(tmp);
		}
	}
	free(s);
}

[lelefante]

Fregato sul tempo :quipy:

[Michele Facchin]

Ahhhh..quindi per passare un puntatore per riferimento ci devo inserire un altro *... ok capito, grazie mille ciao.

[TheGreatWorld]

Ti posso consigliare (invece di passare un array di puntatori) di far ritornare alla funzione la testa della lista. In questo modo puoi garantire anche una corretta gestione degli errori (ritornando NULL e abbinandolo in modo occulato ad errno).

bye