[C] gestione stack push e pop

**oregon** · 11-04-2009, 11:18

Errore in rosso ...

Originariamente inviato da jurij7
cioè in questo modo

codice:

typedef struct stackNode *StackNodePtr;


void push(StackNodePtr *topPtr, int dat);
int pop(StackNodePtr *topPtr);

definisco StackNodePtr come puntatore a StackNode ma alle funzioni passo come argomento topPtr (puntatore a StackNodePtr che è già un puntatore alla struttura StackNode)

ossia faccio anche

codice:

StackNodePtr stackPtr = NULL;

ove stackPtr lo definisco di tipo StackNodePtr (che è un puntatore a StackNode)
quindi stackPtr è puntatore a puntatore StackNode e poi qui

codice:

 y = pop(&stackPtr);
 x = pop(&stackPtr);

passo alla funzione un puntatore a puntatore di StructNode...dico bene?

**jurij7** · 11-04-2009, 11:23

correggo :
stackPtr è di tipo StackNodePtr ove StackNodePtr è puntatore a stackNode...esatto?

la cosa strana è con puntatore a puntatore ..funge lo stesso

cmq così

codice:

#include <stdio.h>
#include <stdlib.h>
#define n 10
/*
 * 
 */

struct stackNode{
    int data;
    struct stackNode *nextPtr;
};

typedef struct stackNode *StackNodePtr;


void push(StackNodePtr topPtr, int dat);
int pop(StackNodePtr topPtr);


int main() {

    struct vettore{
        char OP;
        int NUM;
    } V[n];

    StackNodePtr stackPtr = NULL;
    char o;
    int nu;
    int i,x,y;
    float app;


    for (i = 0; i < n; i++){
        printf ("Inserire il carattere : \n");
        printf ("'O' se operatore aritmetico\n");
        printf ("'N' se operando\n");

        printf ("'F' se forma polacca terminata\n");
		fflush(stdin);

		scanf ("%c", &o);		
		
        V[i].OP = o;
		if (o != 'F'){
        printf ("Inserire il numero : \n");
        scanf ("%d", &nu);
        V[i].NUM = nu;
		}
		else{
			("Stringa finita\n");
		}

    }

    for (i = 0; i < n; i++){
        
        if (V[i].OP == 'N' )
        {
          push (&stackPtr, V[i].NUM);
        }
        if (V[i].OP == 'O'){
            if(!isEmpty(stackPtr)){
                y = pop(&stackPtr);
                x = pop(&stackPtr);
               
                if (V[i].NUM == 1){
                    app = (float)(x + y);
                    push(&stackPtr, app);
                }
                if (V[i].NUM == 2){
                    app = (float)(x - y);
                    push(&stackPtr, app);
                }
                if (V[i].NUM == 3){
                    app = (float)(x * y);
                    push(&stackPtr, app);
                }
                if (V[i].NUM == 4){
                    app = (float)(x/y);
                    push(&stackPtr, app);
                }

            }
        }
        if (V[i].OP == 'F'){
            printf ("Forma polacca terminata \n");
			printf ("Risultato %.2f : ",app);
        }
    }

	system("PAUSE");
    return 0;

}

void push(StackNodePtr *topPtr, int dat)
{
    StackNodePtr newPtr; /*puntatore al nuovo nodo*/

    newPtr = malloc(sizeof(struct stackNode));

    /*inserisce il nodo in cima alla pila*/
 /*newPtr punta al nuovo nodo, in data mette il valore mentre in nextPtr mette il puntatore al top*/
    if (newPtr != NULL){
        newPtr->data = dat; /*assegna il nuovo valore da inserire nella pila */
        newPtr->nextPtr = *topPtr; /*assegna il puntatore alla testa della pila*/
        *topPtr = newPtr; /*ovviamente aggiorna il top della pila con il puntatore al nuovo nodo*/
    }
    else{
        printf("%d non inserito \n", dat);
    }
}

   int pop(StackNodePtr *topPtr)
   {
       StackNodePtr tempPtr; /*puntatore a un nodo temporaneo */
       int popValore;

       tempPtr = *topPtr;
       popValore = (*topPtr)->data;
       *topPtr = (*topPtr)->nextPtr;
       free(tempPtr);

       return popValore;
   }

   int isEmpty(StackNodePtr topPtr)
   {
       return topPtr == NULL;
   }

utilizzando semplicemente puntatori a StackNode (e non puntatori a puntatori)

**jurij7** · 12-04-2009, 14:29

ecco, ho terminato
ho evitato puntatori a puntatori di struttura ed ho usato solo puntatore a struttura

codice:

#include <stdio.h>
#include <stdlib.h>
#define n 4
/*
 *
 */

struct stackNode{
    int data;
    struct stackNode *nextPtr;
};

typedef struct stackNode *Stack;


void push(Stack *topPtr, int dat);
int pop(Stack *topPtr);


int main() {

    struct vettore{
        char OP;
        int NUM;
    } V[n];

    Stack stackPtr = NULL;

    char o;
    int nu,i;
    float x,y;
    float app;


    for (i = 0; i < n; i++){
        printf ("Inserire il carattere : \n");
        printf ("'O' se operatore aritmetico\n");
        printf ("'N' se operando\n");
        printf ("'F' se forma polacca terminata\n");
	fflush(stdin);
        scanf ("%c", &o);
        V[i].OP = o;
	   if (o != 'F'){
              printf ("Inserire il numero : \n");
              scanf ("%d", &nu);
              V[i].NUM = nu;
            }
            else{
		("Stringa finita\n");
		}

    }

    for (i = 0; i < n; i++){

        if (V[i].OP == 'N' )
        {
          push (&stackPtr, V[i].NUM);
        }
        if (V[i].OP == 'O'){
            if(!isEmpty(&stackPtr)){
                y = pop(&stackPtr);
                x = pop(&stackPtr);

                if (V[i].NUM == 1){
                    app = (float)(x + y);
                    push(&stackPtr, app);
                }
                if (V[i].NUM == 2){
                    app = (float)(x - y);
                    push(&stackPtr, app);
                }
                if (V[i].NUM == 3){
                    app = (float)(x * y);
                    push(&stackPtr, app);
                }
                if (V[i].NUM == 4){
                    app = (float)(x/y);
                    push(&stackPtr, app);
                }

            }
        }
        if (V[i].OP == 'F'){
            printf ("Forma polacca terminata \n");
            printf ("Risultato %.2f : ",app);
        }
    }

	system("PAUSE");

    return 0;

}

void push(Stack *topPtr, int dat)
{
    Stack newPtr; /*puntatore al nuovo nodo*/

    newPtr = malloc(sizeof(struct stackNode));

    /*inserisce il nodo in cima alla pila*/
 /*newPtr punta al nuovo nodo, in data mette il valore mentre in nextPtr mette il puntatore al top*/
    if (newPtr != NULL){
        newPtr->data = dat; /*assegna il nuovo dato al nuovo nodo */
        newPtr->nextPtr = *topPtr; /*assegna il puntatore alla testa della pila*/
        *topPtr = newPtr; /*ovviamente aggiorna il top della pila con il puntatore al nuovo nodo*/
    }
    else{
        printf("%d non inserito \n", dat);
    }
}

   int pop(Stack *topPtr)
   {
       Stack tempPtr; /*puntatore a un nodo temporaneo */
       int popValore;

       /*Conserva il puntatore al top in tempPtr che servirà per rilasciare la locazione di memoria del nodo prelevato */
       tempPtr = *topPtr;
       /*Preleva il dato dal primo nodo (puntato da topPtr) e lo salva in popValore*/
       popValore = (*topPtr)->data;
       /*il puntatore del nodo prelevato diventa il topPtr*/
       *topPtr = (*topPtr)->nextPtr;
       /*libera la locazione di memoria del nodo da cui si è prelevato il dato*/
       free(tempPtr);

       return popValore;
   }

   int isEmpty(Stack topPtr)
   {
       return topPtr == NULL;
   }

grazie per la pazienza

**oregon** · 12-04-2009, 18:21

Originariamente inviato da jurij7
ho evitato puntatori a puntatori di struttura ...

E questo

Stack *topPtr

cosa sarebbe?

Discussione: [C] gestione stack push e pop

Strumenti discussione

Ricerca discussione

Visualizza

Permessi di invio