C Pilha no vetor estático com Linguagem C

brunacamily · 4 de junho de 2021

Estou com essa questão de Pilha no vetor estático e ainda estou com bastante duvidas em relação a esse assunto como: se quando o vetor esvaziar ele já vai encerrar o programa direto ou teria como acrescentar os Push e quando está no desenvolvimento do código se fosse possível eu acrescentar algo depois do vetor estar vazio como eu iria fazer isso exatamente ? Se alguém poder me ajudar ficarei agradecida!!

Considere a implementação em linguagem C da estrutura de dados pilha com tamanho fixo.

#define tam 10 

struct pilha{ 
     int dados[tam]; 
     int primeiro; 
     int ultimo; 
}; 

pilha p; 

void pop(){ 
     p.dados[p.ultimo-1] = 0; 
     p.ultimo--; 
}

A Pilha é uma das estruturas mais simples e mais versáteis dentre as utilizadas na computação. A pilha é uma estrutura em a entrada e a saída de dados se dão pela mesma extremidade, chamada de topo da pilha. São estruturas conhecidas como Last In, First Out (LIFO), que pode ser traduzido por Último a Entrar, Primeiro a Sair.

OLIVEIRA, Pietro Martins de; Pereira, Rogério de Leon. Estrutura de Dados I. Maringá-Pr.: Unicesumar, 2019.

Você recebeu o código parcialmente implementado, conforme o código apresentado acima. Seu gerente de projetos, solicitou que você complete este código incluindo as funções: inclusão de elementos PUSH(), função de exibir o pilha DISPLAY(), função principal MAIN().

Considere que durante a execução o usuário do programa executou as seguintes ações
1 - Executou a função POP(), porém o vetor está vazio.
2 - Foi executo 3 vezes a função PUSH();
3 - Executou 1 vez a função DISPLAY();

Neste caso específico, descreva o comportamento da pilha mediante a esta sequência de execuções.

arfneto · 4 de junho de 2021

1 hora atrás, brunacamily disse:

se quando o vetor esvaziar ele já vai encerrar o programa direto

O programa vai agir de acordo com o que escrever. Se você mandar encerrar quando esvaziar a pilha ele vai parar.

1 hora atrás, brunacamily disse:

teria como acrescentar os Push e quando está no desenvolvimento do código se fosse possível eu acrescentar algo depois do vetor estar vazio como eu iria fazer isso exatamente

Em geral a pilha tem nomes consagrados para as funções. push() empilha, pop() desempilha, top() mostra o cara que está no topo. Em alguns casos tem size() que mostra o tamanho da pilha (em uso).

O que o programa vai fazer pode ser feito lendo comandos e encerrando, por exemplo algo simples como

top
push 1
push 2
push -300
top
top
pop
top 
pop
fim

e seu programa rodando esse cenário seria o simples

top
> pilha vazia
push 1
> ok
push 2
> ok
push -300
> ok
top
> -300
top
> -300
pop
> ok
top 
> 2
pop
> ok
fim
> fim: pilha ficou com 1 elemento (s)
Lista: 1

Com o programa respondendo com um > antes de tudo, como um prompt. Assim pode testar os comandos do modo como preferir e só precisa ler a entrada e separar o comando do argumento quando for o caso. E só tem um comando que tem argumentos o push claro.

Simon Viegas · 4 de junho de 2021

@brunacamily, sobre:

8 horas atrás, brunacamily disse:

Seu gerente de projetos, solicitou que você complete este código incluindo as funções: inclusão de elementos PUSH(), função de exibir o pilha DISPLAY(), função principal MAIN().

Eu não entendi se isso seria apenas para abstrair, ou seja: "imaginar que teria implementado", ou se será necessário implementar de fato...

Mas, de um modo geral, acho meio difícil responder isso de cabeça... pois envolveria alguns pormenores do C que, se já tivesse um bom conhecimento na linguagem, por si só não teria dúvidas sobre pilhas, concorda?.

RESUMINDO

Simplesmente implemente as funções push(), pop() e display() e vá testando e "tentando entender" como funciona as coisas em C...

VERSÃO SNYDER CUT

Supondo que isso estaria numa prova de concurso e precisaria responder de cabeça... vamos lá:

Temos:

8 horas atrás, brunacamily disse:

pilha p;

Tá! Qual o valor inicial para as "itens" p.primeiro e p.ultimo ao apenas definir a variável p? Ficam com um lixo da memória ou ficam com 0, já que são int?

Particularmente eu não sabia! Para mim ficaria com um valor "aleatório" ("lixo de memória")... mas testei aqui (compilando um .cpp) e ambas ficaram com 0. Ou seja: é um detalhe muito específico... talvez isso seja até configurável de compilador para compilador, vá saber... No Pascal, por exemplo, se for no "main", a variável é zerada (fica com 0), já se for dentro de uma função, não zera, fica com o lixo.. Tem linguagem que nem deixa compilar! ou seja: depende do "pormenor" lá da linguagem.

Em fim, vamos aceitar aqui que é o padrão "zerar" os int.

Seguindo, vamos "executar" a primeira linha do pop():

8 horas atrás, brunacamily disse:

p.dados[p.ultimo-1] = 0;

Vai então acessar a posição -1 do vetor, certo?... ora! o que acontece quando tenta acessar uma posição que "não existe" no vetor em C? Eu também não fazia ideia... do pouco que conheço em outras linguagem, daria pau!! O programa estouraria.... mas testei aqui e vi que simplesmente "roda".. e aí? O que acontece?... o jeito também é testar... (Usando display() seria um caminho. Vide mais abaixo.)

Daí, pede para inserir novos itens. Vamos inserir o 3, 5 e o 7. Seguindo a mesma lógica "simples", vai primeiro empilhar na posição -1, depois na posição 0, depois na posição 1... certo? O que vai ser impresso?

Então, o que o display() vai mostrar vai depender do que implementar lá... se implementar a "listagem" indo do "p.primeiro" (0) até o "p.ultimo" (1), vai imprimir 7 e 5 (ordem invertida, já que é uma pilha).. o 3 ficaria lá no limbo...

Em fim, para testar, coloquei para imprimir da posição -1 (que não deveria existir no vetor, já que vai de 0 a 9) até o p.ultimo.. aí imprimiu o valor:

Veja:

Mas perceba que não faria muito sentido começar do -1... já que "item p.primeiro não foi mexido no pop()...

Então, de algum modo o C "força" o acesso a uma posição do vetor que não existe (a posição -1). E o programa roda... isso provavelmente tem a ver com o modo que o C gerencia a memória de um modo mais "livre"... menos protegido nesse sentido. (O programador teria mais flexibilidade e ao mesmo tempo mais responsabilidade nesse gerenciamento.)

Conclusão:

Além dos métodos solicitados no enunciado, ficaria implícito que, para um gerenciamento de pilhas, seria "necessário" o uso de outras funções... como init(), para garantir uma inicialização da pilha ou ajudar a resetar; um empty(), para ver se está vazio antes, por exemplo, de tentar retirar um elemento; um full(), para verificar se está cheio antes, por exemplo, de tentar inserir mais dados que a pilha suportaria etc.

Resumindo:

Simplesmente implemente as funções push(), pop() e display() e vá testando e "tentando entender" como funciona as coisas em C... daí, vai tentando identificar a necessidade ou não da implementação de outras funções auxiliares.

Sobre:

9 horas atrás, brunacamily disse:

Considere que durante a execução o usuário do programa executou as seguintes ações
1 - Executou a função POP(), porém o vetor está vazio.
2 - Foi executo 3 vezes a função PUSH();
3 - Executou 1 vez a função DISPLAY();

Neste caso específico, descreva o comportamento da pilha mediante a esta sequência de execuções.

1 - iria "remover" um elemento que sequer foi empilhado; ("Ficaria meio que com um saldo negativo".);

2 - iria inserir os elementos nas posições -1, 0 e 1;

3 - iria exibir os 2 últimos elementos, mas em ordem invertida entre si.

Mas reforçando: a forma que os resultados serão implementando, vai depender diretamente do que será implementado, já que as outras função não foram pré-definidas no enunciado, e nem o enunciado proíbe que o próprio pop() seja ajustado, para por exemplo, exibir "pilha vazia", em vez de "desempilhar algo que não existe", como relatado mais acima..

arfneto · 4 de junho de 2021

11 horas atrás, brunacamily disse:

Pilha no vetor estático

Não faz diferença alguma se é um vetor ou se é estático. Numa estrutura dessas apenas está exposto um elemento, o do topo. E se pode tirar um ou colocar um.

11 horas atrás, brunacamily disse:

Você recebeu o código parcialmente implementado, conforme o código apresentado

#define tam 10 

struct pilha{ 
     int dados[tam]; 
     int primeiro; 
     int ultimo; 
}; 

pilha p; 

void pop(){ 
     p.dados[p.ultimo-1] = 0; 
     p.ultimo--; 
}

Muitas vezes o instrutor apresenta um código ruim de propósito, para testar o aluno ou o leitor. E em outras o autor é ruim mesmo. O que sobra aqui é um código ruim mesmo, e é o caso desse aí.

De todo modo, entenda que em pop() se ultimo for zero vai cancelar o programa

pop() retorna void e não tem argumentos, então a (única) pilha tem que ser global. Uma dupla b0b@g3m. Não seria aceito em lugar nenhum, empresa ou escola.

Na estrutura, primeiro e ultimo talvez não sejam boas escolhas e seria melhor usar primeiro e tamanho para sempre ter a informação do tamanho sem ter que fazer contas.

11 horas atrás, brunacamily disse:

funções: inclusão de elementos PUSH(), função de exibir o pilha DISPLAY(), função principal MAIN().

main() é a função principal. Em C. Não MAIN() ou Main()

Imagino que DISPLAY() seja para mostrar o topo da pilha. Essa é a função. Nessa estrutura o conteúdo da pilha s

o é mostrado em funções de teste, nunca na implementação como uma função pública.

Em geral push() e pop() retornar um status, um int, com zero em caso de sucesso. É óbvio que podem dar erro: pop() em uma pilha vazia vai retornar erro, push() em uma pilha cheia vai dar erro. E por isso retornar void é bobagem. Quase sempre é bobagem retornar void, já que usar o valor de retorno é opcional em C. Ou em C++ a menos de [[nodiscard]].

brunacamily · 4 de junho de 2021

@arfneto

3 horas atrás, arfneto disse:

em pop() se ultimo for zero vai cancelar o programa

Desculpa não entendi, é que você tinha comentado anteriormente que se não colocar para encerrar ele não vai encerrar.

@Simon Viegas Consegui entender muito bem, mas eu fiquei com duvida nessa parte:

4 horas atrás, Simon Viegas disse:

Então, o que o display() vai mostrar vai depender do que implementar lá... se implementar a "listagem" indo do "p.primeiro" (0) até o "p.ultimo" (1), vai imprimir 7 e 5 (ordem invertida, já que é uma pilha).. o 3 ficaria lá no limbo...

Você sabe me dizer se como vai ficar o display no código, eu tentei achar uma explicação nas minhas aula e não consegui achar algum exemplo. Se souber de algum exemplo ficarei grata

arfneto · 4 de junho de 2021

1 hora atrás, brunacamily disse:

Desculpa não entendi, é que você tinha comentado anteriormente que se não colocar para encerrar ele não vai encerrar

Sim, se for de propósito o programa encerra quando você mandar encerrar. Se der um erro como nessa situação que expliquei o programa vai cancelar na mesma hora, mas não por uma decisão do programa e sim por um ERRO do programa. O código que recebeu é muito ruim. Reescreva pop() tambem.

1 hora atrás, brunacamily disse:

Você sabe me dizer se como vai ficar o display no código

Essa função vai mostrar o topo da pilha, no modo "normal".

Se quer mostrar o que tem na pilha programe um loop e mostre os caras. Se qeur mostrar o topo mostre o topo. É só isso: um printf().

A explicação é a mesma: uma pilha é só isso: você coloca uma coisa sobre a outra até o limite. Pode ver só a que está em cima, é a abstração da pilha: o prato de cima da pilha cobre os de baixo e você só pode ver um de cada vez. As funções são bem simples: põe 1, tira 1 mostra o topo. Nada mais.

Exemplo:

Em C++ tem pilhas. Eis as funções:

E como vê não muda nada.

Você não precisa implementar empty() que retorna 1 se a pilha está vazia,

size(0 que retorna o tamanho da pilha, swap() que troca o elemento do topo de uma pilha pelo elemento no topo de outra igual. emplace() é uma forma de push() e as outras funções são as mesmas que está vendo em seu programa

Em java é similar, em Python é similar, em C# é similar. E em qualquer linguagem você pode escrever isso. Uma pilha em COBOL ou FORTRAN seria divertido

Mas C++ e essas outras que falei tem pilhas que você pode declarar e usar. Em C você vai escrever as funções.

Escreva em torno dos dados e não terá dificuldade. E se usar aquilo como mostrei poderá testar qualquer sequência sem esforço.

Essa é a maneira comum de implementar uma pilha, a estrutura bem simples:

#define tam 10 

typedef struct
{ 
     int    dados[tam]; 
     int    primeiro; 
     int    ultimo;
     int    tamanho; 

}    Pilha; 

int         pop(Pilha*); // tira um
int         push(int valor, Pilha* pilha); // coloca valor no topo
int         top(Pilha*); // mostra o valor no topo
int         display(Pilha* pilha); // mostra a pilha toda pra testar
int         tamanho(Pilha* p); // retorna quantos elementos tem na pilha
int         vazia(Pilha* p); // retorna 1 se a pilha está vazia

Como recebeu está ruim e como eu disse recomendo corrigir.

Não precisa de fato corrigir apenas use o ultimo como o tamanho atualizado da pilha.

Se faz questão de usar ultimo como ultimo então use um valor negativo em primeiro para indicar que a pilha está vazia.

Simon Viegas · 4 de junho de 2021

2 horas atrás, brunacamily disse:

@Simon Viegas Consegui entender muito bem, mas eu fiquei com duvida nessa parte:

5 horas atrás, Simon Viegas disse:

Então, o que o display() vai mostrar vai depender do que implementar lá... se implementar a "listagem" indo do "p.primeiro" (0) até o "p.ultimo" (1), vai imprimir 7 e 5 (ordem invertida, já que é uma pilha).. o 3 ficaria lá no limbo...

Você sabe me dizer se como vai ficar o display no código, eu tentei achar uma explicação nas minhas aula e não consegui achar algum exemplo. Se souber de algum exemplo ficarei grata

@brunacamily, como vai ficar iria depender do que foi "exigido" num enunciado... se lá tiver dizendo que você vai simplesmente escrever "Bora Bahêa", você vai lá e escreve isso... então, o que constaria lá seria:

14 horas atrás, brunacamily disse:

função de exibir o pilha DISPLAY()

Suponho que ele quer que exiba todos os dados da pilha... isso fazendo um sentido técnico ou não... Você vai lá e "exibe a pilha". Aí, como vai exibir, como não está especificado no enunciado, vai da sua criatividade e bom senso. Lá na minha postagem anterior fiz um exemplo indicando a posição e o valor que está nela. Segue outro exemplo:

7
5
3

Esse primeiro elemento de baixo podendo ser exibido ou não... mais lá em baixo comento.

Perceba que essa tentativa acima seria simplesmente uma forma de mostrar os dados com eles empilhados... um em cima do outro... como seria numa pilha imaginária... na ordem que foi inserido.. daí, para sair assim precisaria ir lá no código e ajustar de forma que saia assim (seu papel)... Que basicamente seria ir imprimindo na tela o vetor em ordem inversa e pulando uma linha para cada elemento. Ficando um em cima do outro. Absorva que o cerne do conceito de pilha está lá no FIFO... "imaginar" um em cima do outro seria simplesmente uma forma natural de pensar... que faz sentido ~~biológico~~ no dia-dia.. mas que não seria obrigado e ficar um em cima do outro... lembre-se: o cerne está no conceito de FIFO, não importa como estão alinhados ou organizados visualmente... mas seria mais sugestivo seguir uma representação natural, né?

Entende?

Em relação ao exercício, teria que entender qual seria a proposta dele... particularmente entendo que, se ele quer de determinada forma, faz dessa forma... nada impende de ao mesmo tempo você entender que algumas pontos poderiam eventualmente ser feitos de outras formas mais corretas depois.

Minha sugestão: simplesmente implemente cada uma das funções... faça algo! Desse funcionando! E poste o código completo aqui.. Depois, caso necessário, faz outra versão com "melhores práticas" ou ajudamos a "arrumar".

Exemplo de base:

#include<stdio.h>

#define tam 10

struct pilha { 
     int dados[tam]; 
     int primeiro; 
     int ultimo; 
}; 

pilha p; 

void pop(){ 
     p.dados[p.ultimo-1] = 0; 
     p.ultimo--; 
}


void push(int x){ 


}

void display() {

}

int main(void) {
    pop();
    push(3);
    push(5);    
    push(7);
    display();
}

Exemplo de resultado:

Se fosse imprimir do p.ultmo até o p.primeiro.

Não sai o 3, pois estaria numa posição que não existe no vetor. Acredito que esse seria o comportamento esperado para o exercício.

Se fosse imprimir do p.último até o a posição -1... apenas para demonstrar que tá lá...

Essa exibição seria só para demonstrar mesmo que de algum modo o dado é salvo, mesmo numa posição que não deveria existir. Coisas do C (ou da versão que coloquei para compilar aqui).

Por fim... depois, reajustaria todo o código para que ele fique da forma mais correta... que iria "corrigir" também os problemas do código atual (que você eventualmente implementaria antes).

Vide:

5 horas atrás, Simon Viegas disse:

Sobre:

15 horas atrás, brunacamily disse:

Considere que durante a execução o usuário do programa executou as seguintes ações
1 - Executou a função POP(), porém o vetor está vazio.
2 - Foi executo 3 vezes a função PUSH();
3 - Executou 1 vez a função DISPLAY();

Neste caso específico, descreva o comportamento da pilha mediante a esta sequência de execuções.

1 - iria "remover" um elemento que sequer foi empilhado; ("Ficaria meio que com um saldo negativo".);

2 - iria inserir os elementos nas posições -1, 0 e 1;

3 - iria exibir os 2 últimos elementos, mas em ordem invertida entre si.

Ou seja: posteriormente seguiria as orientações do @arfneto, que corrigiria os problemas que o suposto código do enunciado tem.

- passar a receber os dados externos às funções por parâmetro, em vez de usar variável global;

- implementar e usar as funções para prevenir ações inválidas como remover do vazio e inserir num cheio;

etc

RESUMINDO:

OU o enunciado quer que você siga um mesmo fluxo que já está lá e informe o que aconteceria;

OU o enunciado quer que você refatore todo o código e crie uma pilha seguindo os principais conceitos fundamentais do C e pilhas em geral.

A minha sugestão é que você faça as duas coisas!

brunacamily · 5 de junho de 2021

Trabalho I.docx @Simon Viegas @arfneto Eu tentei fazer um codigo aqui conforme o que a gente estava conversando com certeza ainda vai ter alguma coisa para mexer mas tentei fazer conforme

Em 04/06/2021 às 09:33, Simon Viegas disse:

1 - Executou a função POP(), porém o vetor está vazio.
2 - Foi executo 3 vezes a função PUSH();
3 - Executou 1 vez a função DISPLAY();

Trabalho I.docx

arfneto · 5 de junho de 2021

Então você deixou um link para um arquivo do tipo docx, com 13k, o que sugere que não é assim grande.

Aí quem quiser acompanhar a discussão porque acha que pode aprender algo ou ajudar em algo precisa por conta própria baixar um arquivo desconhecido, ter um programa no computador ou acesso a um programa online que abra um arquivo desse tipo, aí vai fazer um download, baixar esse arquivo para algum lugar e afinal rodar um outro programa

Não seria o simples mostrar o texto aqui, a versão nova do código e o que mudou desde a última versão?

Vamos ver...

Fiz o download, abri com Office 365, e para minha surpresa o arquivo docx é um programa em C.

Eis o conteúdo... Note que o Word 365 precisa de várias configurações para salvar isso como texto e sem zoar nada na formatação... Um p0rr3.

#include <stdio.h>
#include <stdlib.h>
#define tam 10
struct pilha {
  int dados[tam];
  int primeiro;
  int ultimo;
};
int pop() {
  int desenfileira() {
    int elemento;
    if (fila.fim == fila ini) {
      printf(“fila vazia.\n”);
    } else {
      elemento = fila.dados[fila.ini];
for (int i=0 ; i < tamanho; i++
fila.dados [fila.fim] = 0;
fila.fim --;
Return elemento;
    }
    void push_back(int a) if (fila.fim == tamanho) {
      printf(“fila cheia.\n” );
    }
    else
  }
  fila.Dados[fila.fim] = elemento;
  fila.Fim++;
}
void push_back(int b) if (fila.fim == tamanho) { printf(“fila cheia.\n” ); }
else
}
fila.Dados[fila.fim] = elemento;
fila.Fim++;
}
void push_back(int c) if (fila.fim == tamanho) { printf(“fila cheia.\n” ); }
else
}
fila.Dados[fila.fim] = elemento;
fila.Fim++;
}
int main(void) {
  pop();
  push(3);
  push(2);
  push(1);
  display();
}
}

Então porque não postar isso simplesmente? O forum é público, os anexos também, mas dificultar o acesso ao código não ajuda nada.

De volta ao programa

Não entendi o que são essas funções push_back() e desenfileira()?

Não entendi nada do que está tentando fazer.

escreva em torno dos dados que tem.

Os dados:

Considere que durante a execução o usuário do programa executou as seguintes ações
1 - Executou a função POP(), porém o vetor está vazio. 
2 - Foi executo 3 vezes a função PUSH();
3 - Executou 1 vez a função DISPLAY();

Isso acima é para ser discutido.

A pilha é assim:

struct pilha{ 
     int dados[tam]; 
     int primeiro; 
     int ultimo; 
}; 

pilha p;

E tem a função pop() assim

void pop(){ 
     p.dados[p.ultimo-1] = 0; 
     p.ultimo--; 
}

O código é ruim, Por várias razões. Pode ser de propósito.

Mas eis o que se sabe:

chamar pop(0 com o vetor vazio

Esse é um caso estranho. Não está sequer definido como se vai determinar se o vetor está vazio. Como eu disse, não se implementa uma pilha assim. Os dados que tem são insuficientes. Pela implementação de pop() se deduz que a pilha começa com ultimo = 9 e vai enchendo a partir de baixo, certo? Ou nada vai funcionar mesmo...
Como saber se ela está vazia? sei lá. Um valor mágico em primeiro, como (-1) pode indicar isso. Como eu disse também, em geral se usa apenas inicio e tamanho, e durante o uso da pilha o inicio vai variando conforme os valores vão sendo alterados, e a pilha é circular. Pode começar no índice 8 e ter 4 elementos, nas posições 8 9 0 e 1. É o simples, para não precisar ficar movendo nada ao extrair elementos.
Só que aqui não tem nada disso. Se chamar pop() com o vetor vazio vai colocar o valor zero no último elemento, mas os elementos são simples int e poderiam já ser TODOS zero. E se ultimo for 0 pop() vai tentar acessar p.dados[-1] e aí o normal seria o seu programa cancelar por acessar um índice inválido.
Foi executo 3 vezes a função PUSH();

Não se pode dizer muito disso: desconsiderando o erro de gramática, se tinha lugar na pilha vai colocar os 3 elementos, e o último a ser inserido vai ficar claro no topo.
Executou 1 vez a função DISPLAY()

Em 03/06/2021 às 23:52, brunacamily disse:

função de exibir o pilha DISPLAY(),

Nesse caso talvez o erro de redação indique que era pra estar escrito "exibir o topo da pilha" que é a função comum. E isso seria o clássico top() para mostrar o elemento que está lá no topo se tiver um. E se for para mostrar todos os elementos entenda que isso não faz sentido exceto para teste. Um pilha como estrutura de dados não tem essa função: todo o conteúdo é oculto exceto o primeiro elemento e talvez o tamanho atual da pilha --- size() --- e/ou se ela está vazia --- empty()

Mas para implementar não faz a menor diferença: eles estão em seguida. Se vai mostrar o primeiro para no primeiro. Se vai mostrar todos, bem, mostra todos...

9 horas atrás, Simon Viegas disse:

Por fim... depois, reajustaria todo o código para que ele fique da forma mais correta... que iria "corrigir" também os problemas do código atual (que você eventualmente implementaria antes)

@Simon ViegasAcho que entendo que quer acelerar a solução recomendando testar logo algo de qualquer jeito, mas considere que o mais caro em termos de escrever programas é o retrabalho. O que custa mais tempo e dinheiro. O recurso mais caro são as pessoas e é o que se evita a todo custo: deixar passar algo ruim (sabendo que está ruim) para corrigir depois. Pode ser uma atitude socialmente até comum: dar uma desculpa, fazer qualquer coisa para depois ver uma solução melhor. Mas em desenvolvimento essas coisas podem levar ao próximo emprego, ao próximo estágio, à próxima dependência . É como o aluno de engenharia que pede para alguém de software escrever o trabalho de C++ porque ele "nunca vai usar isso afinal"... Pode reescrever em meia hora ou passar horas testando uma solução condenada, por exemplo. E não aprender nada, perdendo um tempo pelo caminho para lugar nenhum... Só uma opinião.

Simon Viegas · 5 de junho de 2021

12 horas atrás, arfneto disse:

@Simon ViegasAcho que entendo que quer acelerar a solução recomendando testar logo algo de qualquer jeito, mas considere que o mais caro em termos de escrever programas é o retrabalho. O que custa mais tempo e dinheiro. O recurso mais caro são as pessoas e é o que se evita a todo custo: deixar passar algo ruim (sabendo que está ruim) para corrigir depois. Pode ser uma atitude socialmente até comum: dar uma desculpa, fazer qualquer coisa para depois ver uma solução melhor. Mas em desenvolvimento essas coisas podem levar ao próximo emprego, ao próximo estágio, à próxima dependência . É como o aluno de engenharia que pede para alguém de software escrever o trabalho de C++ porque ele "nunca vai usar isso afinal"... Pode reescrever em meia hora ou passar horas testando uma solução condenada, por exemplo. E não aprender nada, perdendo um tempo pelo caminho para lugar nenhum... Só uma opinião.

@arfneto, eu acho que entendi o que você quis dizer, mas já para mim, acho que eu não consegui transmitir o que eu queria..

Não tem nada a ver com "testar logo" ou de "qualquer jeito", pelo contrário... seria tentar seguir aquilo que supostamente foi pedido... por exemplo: se eu compro uma pizza numa pizzaria e peço ketchup para temperar (enunciado), meio que não caberia ao garçom (programador) me trazer um azeite virgem, argumentando que "não se coloca ketchup em pizza. Tome aqui seu azeite", entende?

Talvez, após o garçom já ter uma experiência e base melhor, chegar para o cliente e argumentaria: "senhor, não seria melhor um azeite em vez de ketchup ?". Então, no contexto eu estaria focando no que supostamente foi pedido: "muito obrigado pela sugestão, mas eu quero ketchup".

Veja: não estou dizendo que foi isso que o enunciado pediu, mas apenas que foi o que eu definir o que poderia ser feito. (Por meu entendimento dos requisitos - errado ou não -, e não por atalhos.)

Tem lá:

Em 04/06/2021 às 09:33, Simon Viegas disse:

Em 03/06/2021 às 23:52, brunacamily disse:

Seu gerente de projetos, solicitou que você complete este código incluindo as funções: inclusão de elementos PUSH(), função de exibir o pilha DISPLAY(), função principal MAIN().

Eu não sei até que ponto pode está implícito a necessidade ou não de uma "refatoração seguindo os padrões mais aceitos ou adequados"... acho que simplesmente estamos abordando um mesmo problema com visões diferentes.

Então, a minha ideia seria que... se o código está de determinada forma, poderia/deveria seguir um mesmo suposto padrão... do código... a ideia de ter problemas poderia ser justamente o foco do exercício... entender que dessa forma vão ocasionar problemas e seria esses problemas que ele espera lá em

:

Em 04/06/2021 às 09:33, Simon Viegas disse:

Neste caso específico, descreva o comportamento da pilha mediante a esta sequência de execuções.

Ou seja: "quais problemas deram ao implementar e testar dessa forma?". Talvez um ponto relacionado seria: "Ora! se o conceito de FIFO é pré-definido, para que iria sugerir a implementação um código para ter as respostas? Bastaria responder pelo conceitos FIFO e os outro princípios já citados de pilha... não precisaria de um código para supor o resultado final.

Já "implementando" errado, teria um contato mais próximo dos problemas, podendo chegar a algo como:

Em 04/06/2021 às 09:33, Simon Viegas disse:

Conclusão:

Além dos métodos solicitados no enunciado, ficaria implícito que, para um gerenciamento de pilhas, seria "necessário" o uso de outras funções [pois sem elas, tem esses tais problemas]... como init(), para garantir uma inicialização da pilha ou ajudar a resetar; um empty(), para ver se está vazio antes, por exemplo, de tentar retirar um elemento; um full(), para verificar se está cheio antes, por exemplo, de tentar inserir mais dados que a pilha suportaria etc.

Resumindo:

Simplesmente implemente as funções push(), pop() e display() e vá testando e "tentando entender" como funciona as coisas em C... daí, vai tentando identificar a necessidade ou não da implementação de outras funções auxiliares.

A minha visão seria para uma jornada de entendimento...

Acho que se resumiria a esse ponto:

21 horas atrás, Simon Viegas disse:

Em relação ao exercício, teria que entender qual seria a proposta dele... particularmente entendo que, se ele quer de determinada forma, faz dessa forma... nada impende de ao mesmo tempo você entender que algumas pontos poderiam eventualmente ser feitos de outras formas mais corretas depois.

Ou seja: eu estou levando em consideração que deveria ser feito aquilo que supostamente teria sido solicitado... só isso. No caminho vai assimilando mais coisas.. mas entendo também essa proposta de refatorar.

ADENDO: [adicionado posteriormente]

Achei uma resposta na internet... minha interpretação seria parecida:

O que divergiria seria que p.primeiro e p.ultimo seriam inicializados com 0. Logo:

1- A variável p.ultimo iria receber -1, e não 0;

2- Daí inseriria na posição -1, 0 e 1; //sim! nos testes o C armazena os dados numa posição inválida

3- Iria exibir na tela apenas as posições 0 e 1. //já que não faria sentido iniciar a impressão do -1, já que não é atualizado o p.primeiro.

Obs.: mesmo no código dele, deveria exibir do segundo em diante.. não faz sentido (para o contexto) atualizar o p.primeiro .

Fonte: https://brainly.com.br/tarefa/43765231

Resumindo: não fez o menos sentido inicializar com 1, já que o vetor começa do 0.