Manipulating batteries in C

Question

I’m a C beginner and I have the following exercise:

The Parking Stationhere contains a single boulevard that guards up to ten cars. There is only one entry/exit in the parking lot, in one edge of the mall. If a customer arrives to remove a car that not be as close to the exit, all cars blocking your the path will leave the parking lot, the customer’s car will be maneuvered out of the parking lot, and the other cars will again occupy the same initial sequence. Write a C script that processes a set of entries. Each entry contains an 'E', input, or an S, exit, and the number plate of the car. It is assumed that the cars arrive and depart in the order specified by the entry. The program must print a message whenever a car arrives or leaves. When a car arrive, the message should specify whether or not there is a vacancy for the car in the parking lot. If there is no parking space, the car will leave without enter the parking lot. When a car leaves the parking lot, message should include the number of times the car has been manoeuvred out of the parking lot to allow other cars out.

The push and pop functions seem to be working normally, but when I assign the push function to another one (maneuver for example), I cannot save to the stack. Follows codes:

struct:

#define 10
struct veiculo
{
    int placa;
    int manobra;
};
struct pilha
{
    struct veiculo item[tamanho];
    int topo;
};

push:

void push(struct pilha *pEstacionamento, struct veiculo *carro, int placaDig, int manobraCar)
{
    if(pCheia(pEstacionamento))
    {
        printf("Estacionamento cheio.");
        getch();
    }
    pEstacionamento->topo = pEstacionamento->topo+1;
    pEstacionamento->item[pEstacionamento->topo].placa = placaDig;
    pEstacionamento->item[pEstacionamento->topo].manobra = manobraCar;

}

struct veiculo pop(struct pilha *pEstacionamento)
{
    struct veiculo valor;
    if(pVazia(pEstacionamento))
    {
        printf("Estacionamento vazio");
        getch();
        valor.placa = -1;
        return valor;
    }

    valor = pEstacionamento->item[pEstacionamento->topo];
    pEstacionamento->topo = pEstacionamento->topo - 1;
    return valor;
}

maneuvering:

void manobra(struct pilha *pEstacionamento, char status, int placa )
{
    struct pilha pEstacionamentoAux;
    inicializa(&pEstacionamentoAux);
    struct veiculo carro;
    int manobraAux;
    int placaAux;

    if(status == 'e')
    {
        if(pCheia(pEstacionamento))
        {
            printf("Estacionamento cheio.");
            getch();
        }

        manobraAux = 0;
        //pega o valor da placa e manobra como zero e add na pilha
        push(&pEstacionamento, &carro, placa, manobraAux);

    }
    else if(status == 's')
    {
        if(pVazia(pEstacionamento))
        {
            printf("Estacionamento vazio");
            getch();

        }

        while(!pVazia(pEstacionamento))
        {
            carro = pop(&pEstacionamento->topo);
            placaAux = carro.placa;
            manobraAux = carro.manobra;

            if(placaAux == placa)
            {
                printf("Seu carro com a placa: %d , foi retirado do estacionamento com %d manobras.", placaAux, manobraAux);
                break;
            }
            else
            {
                manobraAux = manobraAux + 1;
                push(&pEstacionamentoAux, &carro, placaAux, manobraAux);
            }
        }

        while(!pVazia(&pEstacionamentoAux))
        {
            carro = pop(&pEstacionamentoAux);
            placaAux = carro.placa;
            manobraAux = carro.manobra;
            push(&pEstacionamento, &carro, placaAux, manobraAux);
        }
    }

If anyone can help with any tips on how to proceed, thank you.

Answer 1

Following is a (tested) solution to the proposed exercise, the logic is basically the same as its code:

/* ****************************************************************** */
/* *                         estacionamento.c                       * */
/* ****************************************************************** */

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


#define ESTACIONAMENTO_MAX_TAM        (10)
#define PLACA_NULL                    (-1)
#define SUCESSO                       (0)
#define ERRO_ESTACIONAMENTO_CHEIO     (-1)
#define ERRO_MANOBRA_INVALIDA         (-2)


typedef enum manobra_e manobra_t;
typedef struct veiculo_s veiculo_t;
typedef struct estacionamento_s estacionamento_t;


enum manobra_e
{
    manobEntrada,
    manobSaida
};


struct veiculo_s
{
    int placa;
};


struct estacionamento_s
{
    veiculo_t vaga[ ESTACIONAMENTO_MAX_TAM ];
    int qtd;
};


void estacionamento_inicializar( estacionamento_t * e )
{
    memset( e, 0, sizeof(estacionamento_t) );
}


int estacionamento_push( estacionamento_t * e, veiculo_t v )
{
    if( e->qtd == ESTACIONAMENTO_MAX_TAM )
        return ERRO_ESTACIONAMENTO_CHEIO;

    e->vaga[ e->qtd++ ] = v;

    return SUCESSO;
}


veiculo_t estacionamento_pop( estacionamento_t * e )
{
    if( e->qtd == 0 )
    {
        veiculo_t v;
        v.placa = PLACA_NULL;
        return v;
    }

    return e->vaga[ --e->qtd ];
}


int estacionamento_manobrar_veiculo( estacionamento_t * e, manobra_t m, int placa )
{
    switch( m )
    {
        case manobEntrada :
        {
            veiculo_t v;
            v.placa = placa;

            if( estacionamento_push( e, v ) == ERRO_ESTACIONAMENTO_CHEIO )
                return ERRO_ESTACIONAMENTO_CHEIO;

            return 1;
        }

        case manobSaida :
        {
            veiculo_t v;
            estacionamento_t aux;
            int qtd_manobras = 0;

            estacionamento_inicializar( &aux );

            while(1)
            {               
                v = estacionamento_pop( e );

                if( v.placa == PLACA_NULL )
                    break;

                qtd_manobras++;

                if( v.placa == placa )
                    break;

                estacionamento_push( &aux, v );
            }

            while(1)
            {               
                v = estacionamento_pop( &aux );

                if( v.placa == PLACA_NULL )
                    break;

                estacionamento_push( e, v );
            }

            return qtd_manobras;
        }

        default :
        {
            return ERRO_MANOBRA_INVALIDA;
        }
    }
}

void estacionamento_listar_veiculos( estacionamento_t * e )
{
    int i = 0;

    if( !e->qtd )
    {
        printf("Estacionamento Vazio!\n");
        return;
    }

    printf( "Estacionamento:\n" );

    for( i = 0; i < e->qtd; i++ )
        printf( "   Vaga %d / Placa: %d\n", i, e->vaga[i].placa );
}


int main( int argc, char * argv[] )
{
    int qtd = 0;
    estacionamento_t e;

    estacionamento_inicializar( &e );

    estacionamento_listar_veiculos( &e );

    estacionamento_manobrar_veiculo( &e, manobEntrada, 1010 );
    estacionamento_manobrar_veiculo( &e, manobEntrada, 2020 );
    estacionamento_manobrar_veiculo( &e, manobEntrada, 3030 );
    estacionamento_manobrar_veiculo( &e, manobEntrada, 4040 );
    estacionamento_manobrar_veiculo( &e, manobEntrada, 5050 );

    estacionamento_listar_veiculos( &e );

    qtd = estacionamento_manobrar_veiculo( &e, manobSaida, 3030 );

    printf( "Retirei veiculo do estacionamento com %d manobras!\n", qtd );

    estacionamento_listar_veiculos( &e );

    return 0;
}

/* fim-de-arquivo */

I hope I’ve helped!