How do I return the number of items in a stack

Question

******I did this Exercise , however in the count of stack elements, is not appearing the value of items Could help me please ****

#include <stdio.h>
#include <stdlib.h>
/*
  Um elemento da Pilha tem a chave, (e outros campos se necessarios)
  e o endereco(ponteiro) do elemento debaixo na pilha.
*/
typedef struct ITEM_PILHA{
      int chave;
      float val;
      struct ITEM_PILHA *ant;  
}ITEM_PILHA;

/*
 @criaElem: Aloca memoria dinamicamente para um registro(item)
  de uma pilha
*/
ITEM_PILHA *criaElem(int valor, float v){
     ITEM_PILHA *aux;    
     aux = (ITEM_PILHA *)malloc( sizeof(ITEM_PILHA) ); //aloca um novo elemento
     if(!aux) //verifica se nao ha memoria suficiente
          return(NULL);     //devolve um ponteiro nulo

     aux->chave = valor;  //inicializa o novo elemento da fila
     aux->val = v;
     aux->ant = NULL;      
     return(aux);      
}

//@Insere: insere um elemento sempre no topo da pilha (PUSH)
ITEM_PILHA *insere(ITEM_PILHA *topo, int valor, float v){
     ITEM_PILHA *aux;

     aux = criaElem(valor, v);
     if(!aux){
        printf(" Erro de alocacao de memoria\n");      
     }
     else {        
       aux->ant = topo; //liga o novo a pilha
       topo = aux; //move o topo p o novo elemento
     }
     return topo;
}

/*
  @POP: remove elemento do topo da pilha
*/
ITEM_PILHA *removeElem(ITEM_PILHA *topo){ //remove um elemento da pilha
     ITEM_PILHA *aux;

     if( !topo ){ //se estiver vazia mostra mensagem
         printf("\nPilha Vazia.\n");
         getchar();               
     } else {
         printf("Removendo: %d\n", topo->chave);
         getchar();       
         aux = topo; //guarda o topo para liberar depois da memoria
         topo = topo->ant; //o topo recebe o de baixo (anterior)                    
         free(aux); //libera o item da pilha da memória      
     }       
     return topo;     
}

//imprimir todos os elementos da pilha
void imprime(ITEM_PILHA *topo){
     ITEM_PILHA *aux;
     if( !topo ){ //se estiver vazia mostra mensagem
         printf("\nPilha Vazia.\n");
         getchar();               
     }
     else{
          for(aux = topo; aux != NULL; aux = aux->ant)
                  printf("%d \n",aux->chave);
          }
          getchar();
          getchar();       
}

//devolver o numero de itens na pilha
int contaElementos(ITEM_PILHA *topo){
    if(topo==NULL)
        return 0;
    else{
        return (1 + contaElementos(topo->ant));
    }

}

void buscar(ITEM_PILHA *topo, int valor){
    ITEM_PILHA *aux = topo;
    int achou = 0;

    while(aux!=NULL){
        if(aux->chave == valor)
            achou = 1;
        aux = aux->ant; 
    }

    if(achou)
        printf("Encontrado \n");
    else    
        printf(" Nao Encontrado \n");

    getchar();
    getchar();
}

void main(){
     ITEM_PILHA *topo=NULL; //cria a pilha vazia
     char opcao; //opcao do menu
     int chave; //valor a ser inserido pelo usuario
     float v;
     do{
        system("cls");           
        printf("Opcoes:\n |1|-Inserir Elemento \n |2|-Remover Elemento \n |3|-Imprimir\n|4|-Buscar |5|Contar Elementos |6| Sair\n");           
        scanf("%c", &opcao);

        switch(opcao){
           case '1':
                     system("cls"); 
                     printf("\nValor:");
                     scanf("%d", &chave);
                     printf("\nV:");
                     scanf("%f", &v);
                     topo = insere(topo, chave, v);
                     fflush(stdin);
                     break;
           case '2': 
                     topo = removeElem(topo);
                     break;
           case '3':
                    imprime(topo);
                    break;
           case '4':
                    printf("\nValor para buscar:");
                    scanf("%d", &chave);
                    buscar(topo, chave);
                    break;     
            case '5':
                   printf("\nElementos: %d", contaElementos(topo)); 
                   system("pause");
                   break;       
           case '6':          
                     exit(0);                                             
        }
    // getchar();                
     }while(opcao);

     getchar();  
}

Answer 1

You do not need a recursive function to count the amount of elements in the stack. You can use a loop for to iterate on the stack, from its top, as long as there are as many elements, see only:

int pilha_contar( ITEM_PILHA * topo )
{
    ITEM_PILHA * aux;
    int cont = 0;

    for( aux = topo; aux != NULL; aux = aux->ant )
        cont++;

    return cont;
}

Your code can get even better, check it out:

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

#define CHAVE_MAX_LEN  (64)
#define BUF_MAX_LEN    (128)

typedef struct ITEM_PILHA
{
    char chave[ CHAVE_MAX_LEN + 1 ];
    double valor;
    struct ITEM_PILHA * ant;
} ITEM_PILHA;

ITEM_PILHA * pilha_criar( char * chave, double valor )
{
    ITEM_PILHA * e = calloc(1, sizeof(ITEM_PILHA));
    strcpy( e->chave, chave );
    e->valor = valor;
    return e;
}

ITEM_PILHA * pilha_inserir( ITEM_PILHA *topo, char * chave, double valor )
{
    ITEM_PILHA * novo = pilha_criar( chave, valor );
    novo->ant = topo;
    topo = novo;
    return topo;
}

ITEM_PILHA * pilha_remover( ITEM_PILHA * topo )
{
    ITEM_PILHA * aux = NULL;
    if( topo )
        aux = topo->ant;
    free(topo);
    return aux;
}

void pilha_imprimir( ITEM_PILHA * topo )
{
    ITEM_PILHA * aux;
    printf("\n");
    for( aux = topo; aux != NULL; aux = aux->ant )
        printf( "%s = %g\n", aux->chave, aux->valor );
    printf("\n");
}

int pilha_contar( ITEM_PILHA * topo )
{
    ITEM_PILHA * aux;
    int cont = 0;
    for( aux = topo; aux != NULL; aux = aux->ant )
        cont++;
    return cont;
}

ITEM_PILHA * pilha_buscar_chave( ITEM_PILHA * topo, char * chave )
{
    ITEM_PILHA * aux;
    for( aux = topo; aux != NULL; aux = aux->ant )
        if( !strcmp(aux->chave, chave) )
            return aux;
    return NULL;
}

int main( void )
{
    ITEM_PILHA * topo = NULL;
    char buf[BUF_MAX_LEN];
    char chave[CHAVE_MAX_LEN];
    double valor;

    while(1)
    {
        printf("Opcoes:\n");
        printf("|1| Inserir Elemento \n");
        printf("|2| Remover Elemento \n");
        printf("|3| Imprimir\n");
        printf("|4| Buscar\n");
        printf("|5| Contar Elementos\n");
        printf("|6| Sair\n");
        printf("\n-> ");

        fgets( buf, sizeof(buf), stdin );

        switch( buf[0] )
        {
            case '1':
                printf("Chave: ");
                fgets( buf, sizeof(buf), stdin );
                buf[strcspn(buf, "\n")] = 0;
                strcpy( chave, buf );

                if(pilha_buscar_chave( topo, chave ))
                {
                    printf( "\nChave ja existe!\n\n" );
                    break;
                }

                printf("Valor: ");
                fgets( buf, sizeof(buf), stdin );
                valor = atof(buf);

                topo = pilha_inserir( topo, chave, valor );
                break;

           case '2':
                if(!topo)
                {
                    printf( "\nPilha vazia!\n\n" );
                    break;
                }

                printf( "\nRemovendo Chave: %s\n\n", topo->chave );
                topo = pilha_remover(topo);
                break;

           case '3':
                pilha_imprimir(topo);
                break;

           case '4':
                printf("\nBuscar Chave:");
                fgets( buf, sizeof(buf), stdin );
                buf[strcspn(buf, "\n")] = 0;
                strcpy( chave, buf );

                ITEM_PILHA * e = pilha_buscar_chave( topo, chave );

                if(!e)
                {
                    printf( "Chave nao encontrada!\n\n");
                    break;
                }

                printf( "Chave encontrada: %g\n\n", e->valor );
                break;

            case '5':
               printf("\nElementos na pilha: %d\n\n",  pilha_contar(topo) );
               break;

           case '6':
               return 0;
        }
     }
}