c pointeur en tant qu'entrées

Question

Lorsque j'essaie de pousser des éléments dans une pile, j'obtiens une erreur de segmentation, mais si j'ouvre l'adresse de la pile (je les ai marqués avec "!!!") et ses symboles, elle l'accepte. Mais cette fois dans chaque poussée, il crée une nouvelle adresse et n'augmente pas la valeur maximale.

typedef struct 
{ 
    struct table **symbols; // array of the stack 
    int top; //index of the top element 
    int size; //maximum size of the stack 
}stack; 

void push(stack *stck,struct table *element) 
{ 
    if(stck->top == stck->size) 
    { 
     printf("stack is full"); 
     return; 
    } 

    stck = malloc(sizeof(stack));           !!! 
    stck->symbols = (struct table **)malloc(50 * sizeof(struct table*)); !!! 

    printf("top : %d\n",stck->top); 
    stck->top = stck->top++; 
    printf("%d"&stck->top); 
    stck->symbols[stck->top] = element; 
    printf("top : %d\n",stck->top); 
} 

Answer 1

Vous devez construire votre pile avant de pouvoir y pousser quoi que ce soit. Par exemple. créer la fonction stack_new qui allouer de la mémoire pour votre pile et initialiser ses membres:

stack * stack_new (size_t size) 
{ 
    stack * stck = malloc(sizeof(stack)); 
    stck->top = -1; 
    stck->size = size 
    stck->symbols = (struct table **)malloc(size * sizeof(struct table*)); 
    return stck; 
} 

Maintenant, une fois que vous correctement construit votre pile avec la fonction ci-dessus, vous pouvez passer à pousser la fonction.

Answer 2

Vous passez une pile dans une variable appelée stck, mais l'attribution d'une nouvelle structure et en lui attribuant le même pointeur. Ainsi, la pile que vous transmettez n'est jamais modifiée. Je ne pense pas que vous ayez besoin du premier appel malloc.

Answer 3

Avant d'appeler le push, vous allez avoir besoin d'espace malloc pour la pile.

Avec le !!! lignes, vous allouez une nouvelle mémoire à chaque poussée, ce qui est faux.

Sans le !!! lignes, vous n'allouez jamais la mémoire

Answer 4

Si vous transmettez une seule pile de pointeur * stck puis malloc à l'intérieur de la fonction, elle ne reflétera pas une fois que vous aurez quitté la fonction.

Aussi, pourquoi avez-vous besoin d'allouer de la mémoire pour la table pour 50 pointeurs chaque fois que vous voulez pousser?

le faire comme ci-dessous:

struct table 
{ 
    //members go here 
}; 

typedef struct 
{ 
    struct table **symbols; 
    int top; 
    int size; 
}stack; 


struct table *get_elem(void) 
{ 
    //logic for getting elements go here 
} 

void stack_push(stack *stck, struct table *element) 
{ 

    if(stck->top==stck->size) 
    { 
    printf("Stack Full\n"); 
    return; 
    } 

    stck->top++; 
    stck->symbols[stck->top] = element; 
    return; 
} 

void stack_func() 
{ 

struct table *elem = NULL; 
stack *stck = (stack *)malloc(sizeof(stack)); 
if(NULL==stck) 
{ 
    return; 
} 

stck->top = -1; 
stck->symbols = (struct table **)malloc(50 * sizeof(struct table *)); 

if(NULL == stck->symbols) 
{ 
    free(stck); 
    return; 
} 

    stck->size = 49; 

    elem = get_elem(); 
    //do check here for correctness of elem returned from get_elem 

    stack_push(stck, elem); 

    return; 
} 

Hope this helps! :)