[C] Help pseudo stack

[Solido]

Salve ragazzi...sto cercando di fare un programmino semplice che svolge il ruolo di trattare la memoria con la medesima politica di uno stack col linguaggio C....chiaramente mi limito solo alle operazioni push e pop ed eventuale falimento di queste...solo che l'output chiaramente non mi torna ( uso dev c++)

il codice è questo:

//Inclusioni
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

//Definizioni per l'uso dei booleani
typedef unsigned short int Boolean;
#define TRUE 1
#define FALSE 0


struct stack{
       int size;
       int TOS;
       float * buffer;
       };
Boolean push(struct stack * ptr, float value);
Boolean pop(struct stack * ptr, float*value_ptr);
void get_value(float *value_ptr);
void print_value(float value);
void notify_push_failure(void); 
void notify_pop_failure(void);  
int init ( struct stack * ptr, int size);
int get_size(int*size_ptr);    
        
int main (void)
{
     struct stack stack;
     int size;
     float value;
     Boolean exit;
     Boolean result;
     init(&stack,size);
     get_size (&size);
     
     do{
          exit=FALSE;
          printf("\nPremi A se vuoi inserire un valore nello stack, B se vuoi estrarre un valore, X se vuoi uscire:\n");
     
          char selection;
          selection=getchar();
          switch(selection)
          {
                   case 'A':
                        get_value(&value);
                        result= push(&stack,value);
                        if (result==FALSE)
                        notify_push_failure();
                   break;
                   
                   case 'B':  
                         result= pop(&stack,&value);
                         if(result==TRUE)
                         print_value(value);
                         else
                         notify_pop_failure();
                   break;
                   
                   case'X':
                           exit=TRUE; 
                           break;
                           
                   default  :  printf ("\nHai digitato un carattere diverso dai caratteri: A,B,X\n");
        
          }
     
     } while(exit==FALSE && getchar()!=EOF );
    
     system("PAUSE");
}

int get_size(int*size_ptr)
{
     printf("\n Dimensione stack:\n");
     scanf("%d", &size_ptr);
}

int init ( struct stack * ptr, int size)
{
     ptr->size=size;
     ptr->TOS=0;
     ptr->buffer=(float*)malloc(size*sizeof(float));
}

Boolean push(struct stack * ptr, float value)
// se il buffer non è pieno allora restituisce TRUE
{
        if(ptr->TOS<ptr->size)
        {
             
            (ptr->buffer)[ptr->TOS]=value;
            (ptr->TOS)++;
            return TRUE;
        }
        else
        return FALSE;
}

Boolean pop( struct stack * ptr, float*value_ptr)
{
        if(ptr->TOS>0)
        {
              (ptr->TOS)--;
              *value_ptr=(ptr->buffer)[ptr->TOS];
              return TRUE;
        }
        else
               return FALSE;
                 
}        

void get_value(float*value_ptr)
// acquisisce un valore float da tastiera
{
              printf("\n Inserisci un valore");
              scanf("%f%, &value_ptr");
}

void print_value(float value)
{
     printf("\n Il valore estratto\x8A:%f", value);
}

void notify_push_failure(void)
{ 
     printf("\n Il buffer \x8A pieno. Impossibile inserire il valore!\n");
     
}

void notify_pop_failure(void)
{
     printf("\n Il buffer \x8A vuoto. Impossibile estrarre il valore!\n");
      
}

nell'output mi stampa a video due volte la stessa frase poi se richiedo l'operazione di pop mi crasha il programma...

Grazie mille gia da adesso

[wingman87]

Ho corretto buona parte degli errori, ho segnato in rosso le correzioni:

//Inclusioni
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

//Definizioni per l'uso dei booleani
typedef unsigned short int Boolean;
#define TRUE 1
#define FALSE 0


struct stack{
       int size;
       int TOS;
       float * buffer;
       };
Boolean push(struct stack * ptr, float value);
Boolean pop(struct stack * ptr, float*value_ptr);
void get_value(float *value_ptr);
void print_value(float value);
void notify_push_failure(void);
void notify_pop_failure(void);
int init ( struct stack * ptr, int size);
int get_size(int*size_ptr);

int main (void)
{
     struct stack stack;
     int size;
     float value;
     Boolean exit;
     Boolean result;
     get_size (&size);
     init(&stack,size);

     do{
          exit=FALSE;
          printf("\nPremi A se vuoi inserire un valore nello stack, B se vuoi estrarre un valore, X se vuoi uscire:\n");

          char selection;
          selection=getchar();
          switch(selection)
          {
                   case 'A':
                        get_value(&value);
                        result= push(&stack,value);
                        if (result==FALSE)
                        notify_push_failure();
                   break;

                   case 'B':
                         result= pop(&stack,&value);
                         if(result==TRUE)
                         print_value(value);
                         else
                         notify_pop_failure();
                   break;

                   case'X':
                           exit=TRUE;
                           break;

                   default  :  printf ("\nHai digitato un carattere diverso dai caratteri: A,B,X\n");

          }

     } while(exit==FALSE && getchar()!=EOF );

     system("PAUSE");
}

int get_size(int*size_ptr)
{
     printf("\n Dimensione stack:\n");
     scanf("%d", size_ptr);
}

int init ( struct stack * ptr, int size)
{
     ptr->size=size;
     ptr->TOS=0;
     ptr->buffer=(float*)malloc(size*sizeof(float));
}

Boolean push(struct stack * ptr, float value)
// se il buffer non è pieno allora restituisce TRUE
{
        if(ptr->TOS<ptr->size)
        {
            (ptr->buffer)[ptr->TOS]=value;
            (ptr->TOS)++;
            return TRUE;
        }
        else
        return FALSE;
}

Boolean pop( struct stack * ptr, float*value_ptr)
{
        if(ptr->TOS>0)
        {
              (ptr->TOS)--;
              *value_ptr=(ptr->buffer)[ptr->TOS];
              return TRUE;
        }
        else
               return FALSE;

}

void get_value(float*value_ptr)
// acquisisce un valore float da tastiera
{
              printf("\n Inserisci un valore");
              scanf("%f", value_ptr);
}

void print_value(float value)
{
     printf("\n Il valore estratto\x8A:%f", value);
}

void notify_push_failure(void)
{
     printf("\n Il buffer \x8A pieno. Impossibile inserire il valore!\n");

}

void notify_pop_failure(void)
{
     printf("\n Il buffer \x8A vuoto. Impossibile estrarre il valore!\n");

}

[Solido]

Grazie per le correzioni...io pensavo che la & nello scanf ci dovesse sempre essere, solo che cmq non mi torna:
non mi da errori durante la compilazione solo che nella finestra di output inserisco la dimensione e subito dopo mi compare la scritta che dice che non ho premuto nessuno tra i tasti A,B,X.. poi premo ad es. A e mi ridice che non ho digitato i tasti giusti

[wingman87]

La & in genere si usa nello scanf perché si fa un passaggio di parametro per indirizzo (in modo da ritrovare nella variabile il valore inserito dopo la chiamata a scanf) ma nel tuo caso il parametro è un puntatore p, quindi è già un indirizzo, e quindi & non serve (il valore letto si troverà in *p).
L'altro problema è dovuto all'uso che fai di getchar() e dal suo comportamento:
- ogni volta che richiami getchar() viene letto un caratter dal buffer di input
- il carattere di ritorno a capo non viene scartato da getchar()

Quindi per schematizzare l'esecuzione:
1. Richiedi l'immissione della dimensione dello stack
2. L'utente inserisce un valore e digita invio
//Nel buffer avrai "int\n"
3. Leggi un intero dal buffer
//Nel buffer avrai "\n"
4. Leggi un carattere dal buffer per la scelta tra A,B,X
//Viene letto '\n', ora il buffer è vuoto
5. Viene raggiunta la condizione del while (dove usi nuovamente getchar())
6. L'utente digita ad esempio A e invio
//Nel buffer hai "A\n"
7. Il getchar della condizione del while consuma A
//Nel buffer hai "\n"
8. Torni al punto 4.

[Solido]

intanto ho messo uno scanf prima della getchar() ed è migliorato solo che dopo per qualche errore mi crasha la finestra di output

quindi come dovrei rimediare?

[wingman87]

Io aggiungerei un case per ignorare '\n' (l'invio), poi userei selection nella condizione del while al posto della getchar() e infine non stamperei il messaggio che chiedere l'immissione dell'input quando selection=='\n'

[Solido]

Originariamente inviato da wingman87

Io aggiungerei un case per ignorare '\n' (l'invio), poi userei selection nella condizione del while al posto della getchar() e infine non stamperei il messaggio che chiedere l'immissione dell'input quando selection=='\n'

come faccio a ignorare l'invio?
come modifico il while?
come deve essere il codice quindi?

[wingman87]

Mi sembra che ti ho già detto tutto quello che serve per risolvere il problema da solo, non hai interesse a capire quello che stai studiando?
L'unica cosa poco chiara potrebbe essere ignorare l'invio: per far questo aggiungi un case per il carattere '\n' e ci metti solo un break.
Ad ogni modo scusa se ho frainteso.

[Solido]

si ok ma non capisco il senso! il motivo cè che getchar() prendeo INVIO come carattere? se si in che modo?

case: '\n'
break;


e basta oppure una cosa:

int invio;
printf(" - Premi INVIO per continuare - \n");
invio = getchar();[/b]

poi nn capisco il senso del punto 6 del tuo intervento di prima. In che senso ho A nel buffer?
io voglio digitare n numeri dove n=sizeofbuffer e quindi avrò solo numeri nel buffer e non caratteri...
cmq nn ho capito bene quello che mi dici e se ti sta fatica correggermi il codice nn importa..pace, ma fatto sta che per ora non torna molto bene!!!


per ora il codiece è così:

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


//Definizioni per l'uso dei booleani
typedef unsigned short int Boolean;
#define TRUE 1
#define FALSE 0


struct stack{
       int size;
       int TOS;
       float * buffer;
       };
Boolean push(struct stack * ptr, float value);
Boolean pop(struct stack * ptr, float*value_ptr);
void get_value(float *value_ptr);
void print_value(float value);
void notify_push_failure(void); 
void notify_pop_failure(void);  
int init ( struct stack * ptr, int size);
int get_size(int*size_ptr);  
int getchar (void);
  
        
int main (void)
{
     struct stack stack;
     int size;
     float value;
     Boolean exit;
     Boolean result;
     get_size (&size);
     init(&stack,size);
     
     
     do{
          exit=FALSE;
          printf("\nPremi A se vuoi inserire un valore nello stack, B se vuoi estrarre un valore, X se vuoi uscire:\n");
          
     
          char selection;
         int invio;
          selection=getchar();
          scanf("%c", &selection);
          switch(selection)
          {
                   case '\n':
                        printf( " Inserisci un valore");        
                   case 'A':
                   case 'a':
                        get_value(&value);
                        result = push(&stack,value);
                        if (result==FALSE)
                        notify_push_failure();
                       
                   break;
                   
                   case 'B':
                   case 'b':  
                         result= pop(&stack,&value);
                         if(result==TRUE)
                         print_value(value);
                         else
                         notify_pop_failure();
                   break;
                   
                   case'X':
                   case'x':        
                           exit=TRUE; 
                           break;
                           
                   default  :  printf ("\nHai digitato un carattere diverso dai caratteri: A,B,X\n");
        
          }
     
     } while(exit==FALSE && getchar()!=EOF );
    
     system("PAUSE");
}

int get_size(int*size_ptr)
{
     printf("\n Dimensione stack:");
     scanf("%d", size_ptr);
}

int init ( struct stack * ptr, int size)
{
     ptr->size=size;
     ptr->TOS=0;
     ptr->buffer=(float*)malloc(size*sizeof(float));
}

Boolean push(struct stack * ptr, float value)
// se il buffer non è pieno allora restituisce TRUE
{
        if(ptr->TOS<ptr->size)
        {
             
            (ptr->buffer)[ptr->TOS]=value;
            (ptr->TOS)++;
            return TRUE;
        }
        else
        return FALSE;
}

Boolean pop( struct stack * ptr, float*value_ptr)
{
        if(ptr->TOS>0)
        {
              (ptr->TOS)--;
              *value_ptr=(ptr->buffer)[ptr->TOS];
              return TRUE;
        }
        else
               return FALSE;
                 
}        

void get_value(float*value_ptr)
// acquisisce un valore float da tastiera
{
              printf("\n Inserisci un valore");
              scanf("%f%", value_ptr);
}

void print_value(float value)
{
     printf("\n Il valore estratto \x8A:%f", value);
}

void notify_push_failure(void)
{ 
     printf("\n Il buffer \x8A pieno. Impossibile inserire il valore!\n");
     
}

void notify_pop_failure(void)
{
     printf("\n Il buffer \x8A vuoto. Impossibile estrarre il valore!\n");
      
}

E non torna!!!
grazie

[Solido]

intanto nel while ho messto getchar()!='\n'
solo che nn mi fa inserire + di un carattere nel push

[wingman87]

Originariamente inviato da Solido

si ok ma non capisco il senso! il motivo cè che getchar() prendeo INVIO come carattere? se si in che modo?

Non ho capito qual è il tuo dubbio

Originariamente inviato da Solido

poi nn capisco il senso del punto 6 del tuo intervento di prima. In che senso ho A nel buffer?

Riporto qui il punto 6:
6. L'utente digita ad esempio A e invio
//Nel buffer hai "A\n"
Nel buffer va a finire quello che hai digitato, se digiti A e poi premi invio nel buffer avrai il carattere 'A' seguito da '\n' che è la codifica del ritorno a capo

Originariamente inviato da Solido

io voglio digitare n numeri dove n=sizeofbuffer e quindi avrò solo numeri nel buffer e non caratteri...

Il programma ti chiede di digitare un valore da inserire nello stack solo in seguito alla scelta A, io ti stavo spiegando perché non riesci ad entrare in quella scelta (e neanche nelle altre).

Originariamente inviato da Solido

cmq nn ho capito bene quello che mi dici e se ti sta fatica correggermi il codice nn importa..pace, ma fatto sta che per ora non torna molto bene!!!

Quello che chiedi va oltre i limiti del regolamento (darti il codice corretto e via). Io sto tentando di spiegarti come risolvere i problemi in modo che tu possa imparare qualcosa.

[Solido]

Hai ragione solo che nn capisco come rigirare quella porzione di codice...capisco di avere il problema sul push ma nn riesco a risoleverlo
adesso avevo provato con un while nel case A ma lo ripiena senz che ci possa mattere le mani

case 'A':
case 'a':
while(result==TRUE){
get_value(&value);
result = push(&stack,value);}

notify_push_failure();



break;

per quando riguarda la mia prima affermazione chiedo solo a cosa mi serva fare in quel modo... se nn scrivo quello che dici la funzione getchar prende "l'invio" come un carattere acquisito da tastiera?
cmq ora nn mi da + problemi sull'acquisizione del carattere...
solo che col while ripiena il buffer senza darmi la possibilità di inserire valori nonostante richiami la get value

[wingman87]

Originariamente inviato da Solido

Hai ragione solo che nn capisco come rigirare quella porzione di codice...capisco di avere il problema sul push ma nn riesco a risoleverlo
adesso avevo provato con un while nel case A ma lo ripiena senz che ci possa mattere le mani

case 'A':
case 'a':
while(result==TRUE){
get_value(&value);
result = push(&stack,value);}

notify_push_failure();



break;

In che senso lo riempie senza poterci mettere le mani?

Originariamente inviato da Solido

per quando riguarda la mia prima affermazione chiedo solo a cosa mi serva fare in quel modo... se nn scrivo quello che dici la funzione getchar prende "l'invio" come un carattere acquisito da tastiera?

Esatto, quindi la mia idea era quella di ignorarlo, e per far questo un case vuoto mi sembrava la cosa migliore.

case '\n':
  break;

Originariamente inviato da Solido

cmq ora nn mi da + problemi sull'acquisizione del carattere...
solo che col while ripiena il buffer senza darmi la possibilità di inserire valori nonostante richiami la get value

Potresti postare il codice a cui stai facendo riferimento ora? Così lo provo anch'io e tento di capire cosa non va

[Solido]

il codice di ora è così:

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


//Definizioni per l'uso dei booleani
typedef unsigned short int Boolean;
#define TRUE 1
#define FALSE 0


struct stack{
       int size;
       int TOS;
       float * buffer;
       };
Boolean push(struct stack * ptr, float value);
Boolean pop(struct stack * ptr, float*value_ptr);
void get_value(float *value_ptr);
void print_value(float value);
void notify_push_failure(void); 
void notify_pop_failure(void);  
int init ( struct stack * ptr, int size);
int get_size(int*size_ptr);  
int getchar (void);
  
        
int main (void)
{
     struct stack stack;
     int size;
     float value;
     Boolean exit;
     Boolean result;
     get_size (&size);
     init(&stack,size);
     
     
     do{
          exit=FALSE;
          printf("\nPremi A se vuoi inserire un valore nello stack, B se vuoi estrarre un valore, X se vuoi uscire:\n");
          
     
          char selection;
          selection=getchar();
          scanf("%c", &selection);
          switch(selection)
          {
                        
                   case 'A':
                   case 'a':
                        while(result==TRUE){
                        get_value(&value);
                        result = push(&stack,value);}
           
                        notify_push_failure();
                        
                        
                       
                   break;
                   
                   case 'B':
                   case 'b':  
                         result= pop(&stack,&value);
                         if(result==TRUE)
                         print_value(value);
                         else
                         notify_pop_failure();
                   break;
                   
                   case'X':
                   case'x':        
                           exit=TRUE; 
                           break;
                           
                   default  :  printf ("\nHai digitato un carattere diverso dai caratteri: A,B,X\n");
        
          }
     
     } while(exit==FALSE && getchar()!=EOF &&getchar()!='\n' );
    
     system("PAUSE");
}

int get_size(int*size_ptr)
{
     printf("\n Dimensione stack:");
     scanf("%d", size_ptr);
}

int init ( struct stack * ptr, int size)
{
     ptr->size=size;
     ptr->TOS=0;
     ptr->buffer=(float*)malloc(size*sizeof(float));
}

Boolean push(struct stack * ptr, float value)
// se il buffer non è pieno allora restituisce TRUE
{
        if(ptr->TOS<ptr->size)
        {
             
            (ptr->buffer)[ptr->TOS]=value;
            (ptr->TOS)++;
            return TRUE;
        }
        else
        return FALSE;
}

Boolean pop( struct stack * ptr, float*value_ptr)
{
        if(ptr->TOS>0)
        {
              (ptr->TOS)--;
              *value_ptr=(ptr->buffer)[ptr->TOS];
              return TRUE;
        }
        else
               return FALSE;
                 
}        

void get_value(float*value_ptr)
// acquisisce un valore float da tastiera
{
              printf("\n Inserisci un valore");
              scanf("%f%", value_ptr);
}

void print_value(float value)
{
     printf("\n Il valore estratto \x8A:%f", value);
}

void notify_push_failure(void)
{ 
     printf("\n Il buffer \x8A pieno. Impossibile inserire il valore!\n");
     
}

void notify_pop_failure(void)
{
     printf("\n Il buffer \x8A vuoto. Impossibile estrarre il valore!\n");
      
}

dimmi a te che problema da... a me quando digito A per fare push mi ripiena da solo il buffer:mc:

[wingman87]

E' perché non hai inizializzato result a FALSE, quindi non entra nel while. Oppure puoi usare un do-while, così il test del while viene fatto dopo aver provato almeno un inserimento.
Riguardo la condizione del while più esterno io consigliavo di fare

while(exit==FALSE && selection!=EOF);

In questo modo non vengono fatti altri getchar() inutili che potrebbero dare problemi. Resterebbe da ignorare l'invio ma ti ho già spiegato una possibile soluzione.

[Solido]

Grazie!!!apparte che per entrare nel while result dovrà essere TRUE
cmq per quanto riguarda il selection ci avevo gia provato ma mi da errore

adesso il push funziona fino a buffer pieno solo che ora arrivato infondo al push mi dice di premere il tasto per continuare...e si chiude!

[wingman87]

Originariamente inviato da Solido

Grazie!!!apparte che per entrare nel while result dovrà essere TRUE
cmq per quanto riguarda il selection ci avevo gia provato ma mi da errore

adesso il push funziona fino a buffer pieno solo che ora arrivato infondo al push mi dice di premere il tasto per continuare...e si chiude!

Penso sia per colpa di quel getchar()!='\n' nella condizione del while più esterno.
Che errore ti da mettendo il selection nella condizione del while invece del getchar?

[Solido]

mi dice che selection nn è dichiarato in quella funzione...e per quanto riguarda l'impossibilità di continuare dopo che il buffer si è pienato?
ccioè io faccio push fino a che nn si riempie solo che dopo nn mi da la possibilità di fare pop

[wingman87]

Ah, ho capito, ti dice che selection non è visibile perché è dichiarata in un blocco diverso. Basta che sposti la dichiarazione di selection prima del do-while per risolvere quel problema.
Esce subito dopo aver finito i push perché quel getchar()!='\n' nella condizione del while legge l'invio dal buffer di input e quindi esce.

[Solido]

risolto il selection ora resta quel getchar nel while che mi serve altrimenti mi scrive due volte la scritta:
Hai digitato un carattere diverso dai caratteri: A,B,X

grazie ancora