C Incrementar elementos de uma pilha

Junior Conceição · 14 de março de 2020

Galera, preciso fazer um simulador de estacionamento utilizando estrutura de pilha para estacionar os carros e fila para armazenar os funcionários, só que no código o número de carros nunca sai de zero, não importa quantos carros eu adicione, e quando tento mudar alguma coisa na variável que recebe o número de carros, eu obtenho um Segmentation Fault (Core dumped). O código completo é bem grande, por isso separei apenas essa parte:

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

typedef struct Funcionario
{
	char nome[50];
	int id;
	int idade;
	struct Funcionario *prox;
	struct Funcionario *ant;
} func;

typedef struct Carro
{
	char placa[7];
	struct Carro *prox;
} carro;

typedef struct pi
{
	int capacidade;
	carro *ult;
} Pilha;

typedef struct fila
{
	int id;
	func *prim;
	func *ult;
} Fila;

Fila *fila;
Pilha *pilha;
int funcid = 0;

//inicializa pilha de carros
Pilha *iniciapilha(){
	Pilha *nova_pilha;
	nova_pilha = (Pilha *)malloc(sizeof(Pilha));
	nova_pilha->ult = NULL;
	return nova_pilha;
}

//libera pilha
void liberapilha(){
	carro *temp1 = pilha->ult;
	while (temp1 != NULL){
		carro *temp2 = temp1->prox;
		free(temp1);
		temp1 = temp2;
	}
	free(pilha);
}

//inicializa fila
void iniciafila(){
	fila = (Fila *)malloc(sizeof(Fila));
}

//libera fila
void liberafila(){
	func *temp1 = fila->prim;
	while (temp1 != NULL){
		func *temp2 = temp1->prox;
		free(temp1);
		temp1 = temp2;
	}
	free(fila);
}

//fila de funcionarios
void enfileira(func *f){
	fila = (Fila *)malloc(sizeof(Fila));
	fila->id++;
	if (fila->prim == NULL){
		fila->prim = f;
		fila->ult = f;
	}else{
		fila->ult->prox = f;
		f->ant = fila->ult;
		fila->ult = f;
		fila->ult->prox = fila->prim;
}}

//insere funcionário
func *novofunc(char *nome, int idade){
	funcid++;
	func *f = (func *)malloc(sizeof(func));
	strcpy(f->nome, nome);
	f->idade = idade;
	f->prox = NULL;
	f->ant = NULL;
	f->id = funcid;
	return f;
}

//insere carro
carro *novocarro(char *placa){
	carro *car = (carro *)malloc(sizeof(carro));
	strcpy(car->placa, placa);
	car->prox = NULL;
	return car;
}

//rotacionar fila de funcionarios
void rotacionaFila(){
	func *aux = fila->prim;
	if (aux->prox != NULL){
		fila->prim = fila->prim->prox;
		fila->prim->ant = NULL;
		fila->ult->prox = aux;
		aux->ant = fila->ult;
		aux->prox = fila->prim;
		fila->ult = aux;
	}else
		return;
}

//chamar funcionário
char chamarFuncionario(){
	if (fila->prim == NULL){
		printf("Nenhum funcionário cadastrado!\n");
		return 0;
	}else{
		char nome[50];
		strcpy(nome, fila->prim->nome);
		rotacionaFila();
		puts(nome);
	}
	return 0;
}

void push(carro *car, Pilha *nova_pilha){
	if (nova_pilha == NULL)
	{
		nova_pilha->capacidade++;
		if (nova_pilha->ult == NULL){
			nova_pilha->ult = car;
		}
		else
		{
			carro *aux = nova_pilha->ult;
			nova_pilha->ult = car;
			car->prox = aux;
		}
	}
	else
	{
		if (nova_pilha->ult == NULL)
			nova_pilha->ult = car;
		else
		{
			carro *aux = nova_pilha->ult;
			nova_pilha->ult = car;
			car->prox = aux;
		}
	}
	printf("Funcionário ");
	chamarFuncionario();
	printf("colocou o carro ");
	puts(car->placa);
	printf("Total de carros no estacionamento: %d\n", nova_pilha->capacidade);
}

int main(){
	int opcao, idade;
	char nome[50], placa[7];
	iniciafila();
	iniciapilha();
	printf("Escolha uma opcao:\n");
	printf("1. Cadastrar funcionario\n");
	printf("2. Estacionar carro\n");
	while (opcao != 0){
		scanf("%d", &opcao);
		switch (opcao){
		case 1:
			printf("Digite o nome do funcionario que deseja cadastrar:\n");
			setbuf(stdin, NULL);
			scanf("%s", nome);
			printf("Digite a idade:\n");
			scanf("%d", &idade);
			enfileira(novofunc(nome, idade));
			break;
		case 2:
			printf("Digite a placa do carro que deseja estacionar:\n");
			scanf("%s", placa);
			push(novocarro(placa), iniciapilha());
			break;
		default:
			break;
		}
	}
	liberafila();
	liberapilha();
	return 0;
}

KXSY · 15 de março de 2020

O seu maior problema é com as estruturas de dados (pilha e fila para ser mais exato).

Exemplo de uma pilha simples.

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

/* Constantes */
#define T_PILHA 10

/* Tipos */
typedef struct
{
  int *info;
  int tamanho;
  int topo;
  int flag;
}pilha_t;

void DestroiPilha(pilha_t *pilha)
{
  free(pilha->info);
  free(pilha);
}

void PushPilha(pilha_t *pilha, int info)
{
  if(pilha->topo<pilha->tamanho)
  {
    pilha->info[pilha->topo]=info;
    pilha->topo++;
  }
}

int PopPilha(pilha_t *pilha)
{
  pilha->topo--;
  if(pilha->topo>=0)
  {
    return(pilha->info[pilha->topo]);
  }
  else
  {
    pilha->flag=1;
  }
  return(0);
}

int EstouroPilha(pilha_t *pilha)
{
  return(pilha->flag);
}

pilha_t *CriaPilha(int tamanho)
{
  pilha_t *pilha=malloc(sizeof(pilha_t));
  if(pilha==NULL)
    exit(EXIT_FAILURE);
  pilha->info=malloc(sizeof(int)*tamanho);
  if(pilha->info==NULL)
    exit(EXIT_FAILURE);
  pilha->tamanho=tamanho;
  pilha->topo=0;
  pilha->flag=0;
  return(pilha);
}

int TamanhoPilha(pilha_t *pilha)
{
  return(pilha->tamanho);
}

int main(void)
{
  pilha_t *pilha=CriaPilha(T_PILHA);
  if(pilha==NULL)
    return(-1);
  PushPilha(pilha,10);
  PushPilha(pilha,12);
  PushPilha(pilha,13);
  PushPilha(pilha,14);
  printf("\n%i",PopPilha(pilha));
  printf("\n%i",PopPilha(pilha));
  printf("\n%i",PopPilha(pilha));
  printf("\n%i",PopPilha(pilha));
  printf("\n%i",PopPilha(pilha));
  if(EstouroPilha(pilha))
  {
    printf("\nA pilha estourou!\n");
  }
  else
  {
    printf("\nA pilha está Ok.\n");
  }
  printf("\nTamanho da pilha:\t%i",TamanhoPilha(pilha));
  getchar();
  DestroiPilha(pilha);
  return(0);
}

Um exemplo mais avançado

pilha_avançado.zip

arfneto · 16 de março de 2020

Seu programa não está bom ainda...

Se você trocar main() por

int main(int argc, char** argv)
{
	iniciapilha();
	liberapilha();
	return 0;
}

Vai ver que ele já cancela.

Você usa duas estruturas de dados. Teste as duas em separado. Use seu programa para testar seu programa. você declarou por exemplo

Pilha* iniciapilha();

mas não usou o valor em main(). Porque não? não acha que o ponteiro para a fila e o ponteiro para a pilha deveriam estar em main()? Deveriam.

Deixe o código de main() antes de tudo em seu programa. É bom para você e para outros --- como eu agora --- que vão ler seu programa.

Em geral a gente cria essas estruturas de dados bem genéricas e deixa o código pronto e testado em arquivos diferentes, porque a vida fica muito mais simples assim"você sabe que vai usar isso de novo e fica seguro de que está ok. Não coloque dados do programa no código que manipula as estruturas. Ou ao menos ecite ao máximo.

Mudou algo nesse fim de semana em seu código? poste a versão nova se mudou algo.

adicionado 46 minutos depois

Em 14/03/2020 às 19:06, Junior Conceição disse:

utilizando estrutura de pilha para estacionar os carros e fila para armazenar os funcionários, só que no código o número de carros nunca sai de zero, não importa quantos carros eu adicione, e quando tento mudar alguma coisa na variável que recebe o número de carros

A pilha (de carros)

Antes de escrever um programa que usa uma pilha você escreve o código que gerencia a tal pilha. O programa simulador de estacionamento vai usar as funções da tal pilha para fazer seus controles. E para esse programa a maneira como você implementa a pilha deve ser transparente. É melhor pra você assim. Porque? Simples. Se a pilha for genérica você pode usar num simulador de restaurante na próxima semana. Sem mudar uma linha do código da pilha. E se você tiver uma ideia melhor que como criar a tal pilha você só muda essas funções, sem mexer no código do simulador de estacionamento. Por isso não deve ter misturado com o código da pilha campos do tipo carro.

Você parece ter optado por usar uma lista ligada para implementar a pilha e está ok assim. Mas poderia ter optado por um simples vetor de ponteiros. Ou uma tabela no banco de dados. Acho que entendeu a ideia.

Disciplina da pilha

Na estrutura conhecida como pilha o usuário só vê o elemento de cima --- Head. Há dois tipos de pilha, conhecidas como FIFO e LIFO. Os exemplos clássicos:

a pilha de pratos no restaurante self-service: o cliente deveria sempre retirar o prato de cima.. Só um elemento. Essa é a tal LIFO: last in first out: o último a entrar na fila é o primeiro a sair
a fila do banco. O caixa só vê o primeiro cliente. Só um elemento. essa é a FIFO: first in first out.

Imagino que no seu caso dos carros a disciplina deveria ser FIFO porque na prática é assim: os manobristas vão estacionar os carros que estão na frente, que chegaram antes. Claro que uma fila também vai ser usada para controlar os manobristas, mas não fui que especifiquei esse projeto afinal e assim temos que seguir a especificação

Funções da pilha

Imagino que tenha um livro texto ou uma apostila ao menos. Qual seria?

A pilha tem no mínimo essas funções, com nomes consagrados na literatura:

push() insere
pop() retira
peek() retorna o valor do primeiro sem mexer no ponteiro
size() devolve quantos elementos estão em uso no momento
empty() diz se está vazia

Pode ter mais essas que são bem convenientes:

clear() apaga tudo
list() lista os elementos na saida padrão
create() cria uma pilha novinha

São bem simples de implementar e testar. Sugiro escrever e testar primeiro. O que vai usar para implementar não faz diferença. Pode ser uma lista ligada. Pode ser um vetor simples. Não precisa ser eficiente nem rápido nem nada. Num primeiro momento apenas correto.

Uma ordem segura de implementar é list() create() clear() size() empty() push() peek() pop()