C pilha estatica tan complicado

pilha da depressão · 28 de maio de 2019

Galera tenho que fazer uma pilha que gurda processo , que contenha um nome e um PID, pórem o pid tem que ser gerado altomaticamente um numero

tem que ter as opção insirir , remover, limpa pilha, e fechar pograma , to travado ai!

Segue o código todo:

<CODE>

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#define tamanho 5

typedef struct tipo_gera{
char nome[15];
int PID;
}tipo_gera;

typedef struct tipo_pilha{
   tipo_gera dados[tamanho];
   int ini;
   int topo;
}tipo_pilha;

tipo_pilha pilha;

void empilha(tipo_gera elemento){

if(pilha.topo == tamanho){

       printf("Pilha cheia.\n");
       system("pause");
   }
   else
   {

       pilha.dados[pilha.topo] = elemento;
       pilha.topo++;
   }
}

tipo_gera desempilha(){

tipo_gera elemento;

   if(pilha.topo == pilha.ini){

       printf("Pilha vazia.\n");
       system("pause");
   }
   else
   {

       elemento = pilha.dados[pilha.topo];
       return elemento;
   }
}

int main(){

   pilha.topo = 0;
   pilha.ini = 0;
   int aux, numero, n1;
   tipo_gera elemento;
   tipo_gera guarda;


   do {


   system("cls");
   for(int i=pilha.ini;i<pilha.topo;i++){
       printf("\n -----dados da pilha------ \n");
           printf("------PID : %d - nome :%s-----\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );
   }

   printf(" [1] inseriri um novo elemento.\n\n");
   printf(" [2] remover um elemento.\n\n");
   printf   (" [3] esvaziar a pilha.\n\n");
   printf   (" [0]encerra o pograma.\n ");
       scanf ("%d",&numero);

   elemento.PID =1;


switch (numero){

   case 1 :

       printf("Insira o processo \n");
       scanf("%s", elemento.nome);
       empilha(elemento);


       //   printf("\n dados da pilha: \n");
       //   printf("PID : %d - nome :%s\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );
           break;

   case 2 :
          guarda = desempilha();
          printf("\nProcesso que foi desempilhado \n");
           printf("PID : %d - nome :%s\n",guarda.PID,guarda.nome );
           break;



}
}while (numero >0);

printf("pograma finalizado \n volte sempre!\n");

system("pause");

return 0;
}

Flávio Pedroza · 29 de maio de 2019

system("cls");
     for(int i=pilha.ini;i<pilha.topo;i++){
        printf("\n -----dados da pilha------ \n");
            // printf("------PID : %d - nome :%s-----\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );
            printf("------PID : %d - nome :%s-----\n\n",pilha.dados[i].PID,pilha.dados[i].nome );
     }

Encontrei esse erro mais óbvio em seu programa.

você também precisar de uma variável para gerar automaticamente o PID:

typedef struct tipo_pilha{
    tipo_gera dados[tamanho];
    int ini;
    int topo;
    int PID; //crie essa variavel
}tipo_pilha;

Faça o elemento.PID = tipo_pilha.PID; antes de empilhar e após incremente o valor: tipo_pilha.PID++;

Caso ainda tenha problemas, poste neste tópico novamente.

pilha da depressão · 29 de maio de 2019

5 horas atrás, Flávio Pedroza disse:
system("cls");
     for(int i=pilha.ini;i<pilha.topo;i++){
        printf("\n -----dados da pilha------ \n");
            // printf("------PID : %d - nome :%s-----\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );
            printf("------PID : %d - nome :%s-----\n\n",pilha.dados[i].PID,pilha.dados[i].nome );
     }
Encontrei esse erro mais óbvio em seu programa.

você também precisar de uma variável para gerar automaticamente o PID:
typedef struct tipo_pilha{
    tipo_gera dados[tamanho];
    int ini;
    int topo;
    int PID; //crie essa variavel
}tipo_pilha;
Faça o elemento.PID = tipo_pilha.PID; antes de empilhar e após incremente o valor: tipo_pilha.PID++;

Caso ainda tenha problemas, poste neste tópico novamente.

po mano ainda n saiu muita coisa n , tem como explicar melhor

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#define tamanho 5

typedef struct tipo_gera{
char nome[15];
int PID;
}tipo_gera;

void pilha_limpar(){
   for(i=0; i <=4; i++){
       pilha.dados = 0;
   }

}

typedef struct tipo_pilha{
tipo_gera dados[tamanho];
int ini;
int topo;
int PID; //crie essa variavel
}tipo_pilha;

tipo_pilha pilha;

void empilha(tipo_gera elemento){

if(pilha.topo == tamanho){

       printf("Pilha cheia.\n");
       system("pause");
   }
   else
   {

       pilha.dados[pilha.topo] = elemento;
       pilha.topo++;

   }

}

tipo_gera desempilha(){

tipo_gera elemento;

   if(pilha.topo == pilha.ini){

       printf("Pilha vazia.\n");
       system("pause");
   }
   else
   {

       elemento = pilha.dados[pilha.topo];
       return elemento;
   }
}

int main(){

   pilha.topo = 0;
   pilha.ini = 0;
   int aux, numero, n1;
   tipo_gera elemento;
   tipo_gera guarda;


   do {

   system("cls");
for(int i=pilha.ini;i<pilha.topo;i++){
printf("\n -----dados da pilha------ \n");
// printf("------PID : %d - nome :%s-----\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );
printf("------PID : %d - nome :%s-----\n\n",pilha.dados.PID,pilha.dados.nome );
}

   printf(" [1] inseriri um novo elemento.\n\n");
   printf(" [2] remover um elemento.\n\n");
   printf   (" [3] esvaziar a pilha.\n\n");
   printf   (" [0]encerra o pograma.\n ");
       scanf ("%d",&numero);



switch (numero){

   case 1 :

       printf("Insira o processo \n");
       scanf("%s", elemento.nome);
       empilha(elemento);

       //   printf("\n dados da pilha: \n");
       //   printf("PID : %d - nome :%s\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );
           break;

   case 2 :
          guarda = desempilha();
          printf("\nProcesso que foi desempilhado \n");
           printf("PID : %d - nome :%s\n",guarda.PID,guarda.nome );
           break;




}

}while (numero >0);

printf("pograma finalizado \n volte sempre!\n");

system("pause");

return 0;
}

kode v · 29 de maio de 2019

Pode usar esse e mudar numero para texto , já esta praticamente com precisa posta ai se conseguir mudar

#include <stdio.h>

#include <stdlib.h>

#include <locale.h>

// DEFININDO O TAMANHO

#define tamanho 5

//DECLARANDO A ESTRUTURA

typedef struct tipo_pilha {

int dados[tamanho];

int topo;

int ini;

} pilha_tipo;

// VARIÁVEIS GLOBAIS

tipo_pilha pilha;

int op;

//FUNÇÃO DE RETORNO PARA MOSTRAR A PILHA

void mostrar_pilha()
{

int i;

printf("\nSua pilha: \n\n");

for (i = 0; i < tamanho; i++) {
printf("%d \n", pilha.dados);
}
}

// FUNÇÃO DE RETORNO PARA RETORNAR O MENU

void mostrar_menu()
{

printf("\n\n1 - Adicionar elemento na pilha.\n"

"2 - Excluir elemento da pilha.\n"

"3 - Esvaziar a pilha totalmente.\n"

"0 - Encerrar o programa.\n");
}

//FUNÇÃO PARA EMPILHAR OS ELEMENTOS

void empilhando()
{

if (pilha.topo == tamanho) {

printf("A pilha está cheia!");

system("pause");
}

else {

printf("\nDigite o elemento a ser empilhado: ");

scanf("%d", &pilha.dados[pilha.topo]);

pilha.topo++;
}
}

//FUNÇÃO PARA DESEMPILHAR OS ELEMENTOS

void desempilhando()
{

if (pilha.ini == pilha.topo) {

printf("A pilha está vazia!\n");

system("pause");
}

else {

pilha.dados[pilha.topo - 1] = 0;

pilha.topo--;
}
}

// FUNÇÃO PARA ESVAZIAR A PILHA

void esvaziar_pilha()
{

int i;

if (pilha.topo == pilha.ini) {

printf("A pilha já está vazia!\n\n");

system("pause");
}

else {

for (i = 0; i < tamanho; i++)
{

pilha.dados[pilha.topo - 1] = 0;

pilha.topo--;

}
}

}

int main()
{

setlocale(LC_ALL, "Portuguese");

pilha.topo = 0;

pilha.ini = 0;

op = 1;

while (op != 0)
{

mostrar_pilha();

mostrar_menu();

printf("\nEscolha sua opcao: ");

scanf("%d", &op);

switch (op)
{

case 1 :

empilhando();

break;

case 2 :

desempilhando();

break;

case 3 :

esvaziar_pilha();

break;

}
}

return (0);
}

pilha da depressão · 30 de maio de 2019

ta dendo muito lixo de memoria nela mano , a tela fica bem poluida

kode v · 30 de maio de 2019

O seu programa precisa mostrar "O menu sempre deve imprimir o conteúdo da pilha (da base em direção ao topo);"

são essas informações

Os dados a serem armazenados na pilha devem simular processos, sendo que cada elemento a empilhar/desempilhar deve possuir:

- O PID do cada processo (Process ID, é um código gerado automaticamente pelo sistema – cada processo tem seu próprio PID);
- O nome do programa/comando que gerou o processo.

O programa deve ter um menu principal em forma de laço de repetição que atenda aos seguintes requisitos:

- O menu sempre deve imprimir o conteúdo da pilha (da base em direção ao topo);
- Após a impressão do conteúdo da pilha, o usuário deve ser informado de que pode realizar as seguintes operações:

1) Inserir um elemento na pilha;
2) Remover um elemento da pilha;
3) Esvaziar a pilha;
0) Encerrar o programa.

A operação “Inserir um elemento na pilha” deve pedir para que o usuário informe o nome do programa ou comando que será empilhado. O programa deve associar um PID a esse nome automaticamente, e empilhar ambos os dados: PID + nome. Caso a pilha esteja cheia, o usuário deve receber uma mensagem informando: “Pilha cheia, impossível empilhar mais elementos.”.

A operação “Remover um elemento da pilha” tentar remover um elemento da pilha. Caso haja elemento para ser removido, o PID e o nome do elemento desempilhado devem ser impressos na tela. Caso não seja possível desempilhar elementos, o programa deve imprimir a mensagem “Pilha vazia, impossível desempilhar elementos.”, na tela.

A operação “Esvaziar a pilha” deve remover todos os elementos da pilha.

A operação “Encerrar programa” deve finalizar o processo.

pilha da depressão · 30 de maio de 2019

sim isso ai mesmo , você tb e de ADS ne ?

kode v · 30 de maio de 2019

sim , hehehe

przinho · 30 de maio de 2019

Alguém conseguiu evoluir neste código? Também estou travado nele, rs

kode v · 30 de maio de 2019

falta o menu agora

#include <stdio.h>

#include <stdlib.h>

#include <locale.h>

// DEFININDO O TAMANHO

#define tamanho 5

//DECLARANDO A ESTRUTURA

typedef struct tipo_proc {

char nome[10];

int PID;
} tipo_proc;

typedef struct tipo_pilha {

tipo_proc dados [tamanho];

int topo;

int ini;

} tipo_pilha;

// VARIÁVEIS GLOBAIS

tipo_pilha pilha;

int op;

//FUNÇÃO DE RETORNO PARA MOSTRAR A PILHA

void mostrar_pilha()
{

int i;

printf("\nSua pilha: \n\n");

for (i = 0; i < tamanho; i++) {
printf("%d \n", pilha.dados);
}
}

//FUNÇÃO PARA EMPILHAR OS ELEMENTOS

void empilhando(tipo_proc elemento)
{

if (pilha.topo == tamanho) {

printf("A pilha está cheia!");

system("pause");
}

else {

       pilha.dados[pilha.topo] = elemento;

pilha.topo++;

}
}

//FUNÇÃO PARA DESEMPILHAR OS ELEMENTOS

tipo_proc desempilhando()
{
tipo_proc elemento;
if (pilha.ini == pilha.topo) {

printf("A pilha está vazia!\n");

system("pause");
}

else {

elemento = pilha.dados[pilha.topo];
for(int i=0; i<tamanho; i++)
pilha.dados = pilha.dados[i+1];
pilha.topo--;
return elemento;
}
}

// FUNÇÃO PARA ESVAZIAR A PILHA

void esvaziar_pilha()
{

int i;

if (pilha.topo == pilha.ini) {

printf("A pilha já está vazia!\n\n");

system("pause");
}

else {

for (i = 0; i < tamanho; i++)
{

pilha.dados[pilha.topo];

pilha.topo--;

}
}

}

int main()
{
setlocale(LC_ALL, "Portuguese");

pilha.topo = 0;

pilha.ini = 0;
tipo_proc processo;
processo.PID = 0;
op = 1;
printf("\nInsira o nome do processo:\n");
scanf("%s",&processo.nome);
fflush(stdin);

empilhando(processo);

printf("\n -----dados da pilha------ \n");
printf("------PID : %d - nome :%s-----\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );

}

adicionado 1 minuto depois

1 minuto atrás, vguimil disse:

falta o menu agora

#include <stdio.h>

#include <stdlib.h>

#include <locale.h>

// DEFININDO O TAMANHO

#define tamanho 5

//DECLARANDO A ESTRUTURA

typedef struct tipo_proc {

char nome[10];

int PID;
} tipo_proc;

typedef struct tipo_pilha {

tipo_proc dados [tamanho];

int topo;

int ini;

} tipo_pilha;

// VARIÁVEIS GLOBAIS

tipo_pilha pilha;

int op;

//FUNÇÃO DE RETORNO PARA MOSTRAR A PILHA

void mostrar_pilha()
{

int i;

printf("\nSua pilha: \n\n");

for (i = 0; i < tamanho; i++) {
printf("%d \n", pilha.dados);
}
}

//FUNÇÃO PARA EMPILHAR OS ELEMENTOS

void empilhando(tipo_proc elemento)
{

if (pilha.topo == tamanho) {

printf("A pilha está cheia!");

system("pause");
}

else {

       pilha.dados[pilha.topo] = elemento;

pilha.topo++;


}
}

//FUNÇÃO PARA DESEMPILHAR OS ELEMENTOS

tipo_proc desempilhando()
{
       tipo_proc elemento;
if (pilha.ini == pilha.topo) {

printf("A pilha está vazia!\n");

system("pause");
}

else {

elemento = pilha.dados[pilha.topo];
for(int i=0; i<tamanho; i++)
pilha.dados = pilha.dados[i+1];
pilha.topo--;
       return elemento;
}
}

// FUNÇÃO PARA ESVAZIAR A PILHA

void esvaziar_pilha()
{

int i;

if (pilha.topo == pilha.ini) {

printf("A pilha já está vazia!\n\n");

system("pause");
}

else {

for (i = 0; i < tamanho; i++)
{

pilha.dados[pilha.topo];

pilha.topo--;

}
}

}

int main()
{
setlocale(LC_ALL, "Portuguese");

pilha.topo = 0;

pilha.ini = 0;
tipo_proc processo;
processo.PID = 0;
op = 1;
printf("\nInsira o nome do processo:\n");
scanf("%s",&processo.nome);
fflush(stdin);

empilhando(processo);

printf("\n -----dados da pilha------ \n");
printf("------PID : %d - nome :%s-----\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );


}

falta a biblioteca também #include <string.h>

argolo.david · 31 de maio de 2019

Ola senhores, boa madrugada.

Estou tentando finalizar, mas ta osso essa PILHA.

To tentando linkar o meu menu, mas nao consigo de jeito nenhum.

Alguem poderia me ajudar com m exemplo?

Obrigado.

Everton Borchardt · 31 de maio de 2019

@argolo.david tenta algo parecido com isso :

while(op != 0){ // inicializa antes do while com valor 1
        printf("\n ---------------------* Pilha *----------------------- \n");
        
        imprime_pilha(); //metodo que imprime a pilha
        
        cout<<"\n\n1 - Adicionar elemento na pilha.\n";
        cout<<"2 - Excluir elemento da pilha.\n";
        cout<<"3 - Esvaziar a pilha totalmente.\n";
        cout<<"0 - Encerrar o programa.\n";
        cout<<"S. sair \n";
        cin>>op;
        
        switch (op)
        {

              case 1 :
                cout<<"Digite o elemento a ser empilhado: \n";
                cin>> dado.nome;
                
                empilhar(); //metodo que empilha;

              break;

              case 2 :

                desempilhar(); //metodo que desempilha

              break;

              case 3 :

                esvaziar_pilha(); //metodo que esvazia

              break;

        }
    }

argolo.david · 31 de maio de 2019

@Everton Borchardt

Valeu pela ajuda.

Meu codigo ta quase funcionando, mas ele ta abrindo, direto, preenchendo as linhas e apenas me dando a opção de selecionar qualquer tecla para fechar.

Não consigo vizualizar onde esta o erro.

Poderia me dar um toque?

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>
#include <iostream>
#include <iomanip>

// DEFININDO O TAMANHO
#define tamanho 5

//DECLARANDO A ESTRUTURA
typedef struct tipo_proc {
char nome[10];
int PID;
} tipo_proc;

typedef struct tipo_pilha {
tipo_proc dados [tamanho];
int topo;
int ini;
} tipo_pilha;

// VARIÁVEIS GLOBAIS
tipo_pilha pilha;
int op;

//FUNÇÃO DE RETORNO PARA MOSTRAR A PILHA
void mostrar_pilha()
{
int i;
printf("\nSua pilha: \n\n");
for (i = 0; i < tamanho; i++) {
printf("%d \n", pilha.dados);
}
}

//FUNÇÃO PARA EMPILHAR OS ELEMENTOS
void empilhando(tipo_proc elemento)
{
if (pilha.topo == tamanho) {
printf("A pilha está cheia, impossivel empilhar!");
system("pause");
}

else {
pilha.dados[pilha.topo] = elemento;
pilha.topo++;

}
}

//FUNÇÃO PARA DESEMPILHAR OS ELEMENTOS
tipo_proc desempilhando()
{
tipo_proc elemento;
if (pilha.ini == pilha.topo) {
printf("A pilha está vazia, impossivel desempilhar!\n");
system("pause");
}
else {
elemento = pilha.dados[pilha.topo];
for(int i=0; i<tamanho; i++)
pilha.dados[pilha.topo]=elemento;
pilha.topo--;
return elemento;
}
}

// FUNÇÃO PARA ESVAZIAR A PILHA

void esvaziar_pilha()
{

int i;

if (pilha.topo == pilha.ini) {
printf("A pilha esta vazia, impossivel esvaziar!\n\n");
system("pause");
}

else {

for (i = 0; i < tamanho; i++)
{
pilha.dados[pilha.topo];
pilha.topo--;
}
}
}

int main()
{
setlocale(LC_ALL, "Portuguese");
pilha.topo = 0;
pilha.ini = 0;
tipo_proc processo;
processo.PID = 0;
mostrar_pilha();
while(op != 0){ // inicializa antes do while com valor 1
printf("\n ---------------------* Pilha *----------------------- \n");

mostrar_pilha(); //metodo que imprime a pilha

printf("1 - Adicionar elemento na pilha.\n");
printf("2 - Excluir elemento da pilha.\n");
printf("3 - Esvaziar a pilha totalmente.\n");
printf("0 - Encerrar o programa.\n");
printf("S. sair \n");

switch (op)
{

case 1 :
printf("Digite o elemento a ser empilhado: \n");
empilhando(processo); //metodo que empilha;

break;

case 2 :

desempilhando(); //metodo que desempilha

break;

case 3 :

esvaziar_pilha(); //metodo que esvazia

break;

}
}
/*printf("\nInsira o nome do processo:\n");
scanf("%s",&processo.nome);
fflush(stdin);
*/
empilhando(processo);

printf("\n dados da pilha \n");
printf("PID : %d - nome :%s\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );

}

Flávio Pedroza · 31 de maio de 2019

Acrescenta essas linhas:

mostrar_pilha();
op = 1; //acrescentar
while(op != 0){
(...)
printf("S. sair \n");
scanf ("%d", &op); //acrescentar              
switch (op)

Deve funcionar agora.

argolo.david · 31 de maio de 2019

@Flávio Pedroza

Flavio, obrigado pela dica. Ja deu uma melhorada, mas inda não consigo utilizar.

A pilha esta vindo cheia, então nao consigo usar o programa.

se puder me ajudar, agradeço.

Segue abaixo o retorno da tela.

#include <stdlib.h>
#include <stdio.h>
#include <locale.h>
#include <string.h>
#include <iostream>
#include <iomanip>

// DEFININDO O TAMANHO
#define tamanho 5

//DECLARANDO A ESTRUTURA
typedef struct tipo_proc {
char nome[10];
int PID;
} tipo_proc;

typedef struct tipo_pilha {
tipo_proc dados [tamanho];
int topo;
int ini;
} tipo_pilha;

// VARIÁVEIS GLOBAIS
tipo_pilha pilha;
int op;

//FUNÇÃO DE RETORNO PARA MOSTRAR A PILHA
void mostrar_pilha()
{
int i;
printf("\nSua pilha: \n\n");
for (i = 0; i < tamanho; i++) {
printf("%d \n", pilha.dados);
}
}

//FUNÇÃO PARA EMPILHAR OS ELEMENTOS
void empilhando(tipo_proc elemento)
{
if (pilha.topo == tamanho) {
printf("A pilha está cheia, impossivel empilhar!");
system("pause");
}

else {
pilha.dados[pilha.topo] = elemento;
pilha.topo++;

}
}

//FUNÇÃO PARA DESEMPILHAR OS ELEMENTOS
tipo_proc desempilhando()
{
tipo_proc elemento;
if (pilha.ini == pilha.topo) {
printf("A pilha está vazia, impossivel desempilhar!\n");
system("pause");
}
else {
elemento = pilha.dados[pilha.topo];
for(int i=0; i<tamanho; i++)
pilha.dados[pilha.topo]=elemento;
pilha.topo--;
return elemento;
}
}

// FUNÇÃO PARA ESVAZIAR A PILHA

void esvaziar_pilha()
{

int i;

if (pilha.topo == pilha.ini) {
printf("A pilha esta vazia, impossivel esvaziar!\n\n");
system("pause");
}

else {

for (i = 0; i < tamanho; i++)
{
pilha.dados[pilha.topo];
pilha.topo--;
}
}
}

int main()
{
setlocale(LC_ALL, "Portuguese");
pilha.topo = 0;
pilha.ini = 0;
tipo_proc processo;
processo.PID = 0;
mostrar_pilha();
       op = 1; //acrescentar
       while(op != 0){       // inicializa antes do while com valor 1
printf("\n ---------------------* Pilha *----------------------- \n");

mostrar_pilha(); //metodo que imprime a pilha

printf("1 - Adicionar elemento na pilha.\n");
printf("2 - Excluir elemento da pilha.\n");
printf("3 - Esvaziar a pilha totalmente.\n");
printf("0 - Encerrar o programa.\n");
       printf("S. sair \n");
       scanf ("%d", &op); //acrescentar
       switch (op)
{

case 1 :
printf("Digite o elemento a ser empilhado: \n");
empilhando(processo); //metodo que empilha;

break;

case 2 :

desempilhando(); //metodo que desempilha

break;

case 3 :

esvaziar_pilha(); //metodo que esvazia

break;

}
}
printf("\nInsira o nome do processo:\n");
scanf("%s",&processo.nome);
fflush(stdin);

empilhando(processo);

printf("\n dados da pilha \n");
printf("PID : %d - nome :%s\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );

}

kode v · 31 de maio de 2019

isso já resolve o problema , o pior e o PID que tem que gera automático , se tiver algum ideia ?

#include <stdlib.h>
#include <stdio.h>
#include <locale.h>
#include <string.h>
#include <iostream>
#include <iomanip>

// DEFININDO O TAMANHO
#define tamanho 5

//DECLARANDO A ESTRUTURA
typedef struct tipo_proc {
char nome[10];
int PID;
} tipo_proc;

typedef struct tipo_pilha {
tipo_proc dados [tamanho];
int topo;
int ini;
} tipo_pilha;

// VARIÁVEIS GLOBAIS
tipo_pilha pilha;
int op;

//FUNÇÃO DE RETORNO PARA MOSTRAR A PILHA
void mostrar_pilha()
{
int i;
printf("\nSua pilha: \n\n");
for (i = 0; i < tamanho; i++) {
printf("%d \n", pilha.dados);
}
}

// FUNÇÃO DE RETORNO PARA RETORNAR O MENU

   void mostrar_menu()
   {

   printf("\n\n1 - Adicionar elemento na pilha.\n"

   "2 - Excluir elemento da pilha.\n"

   "3 - Esvaziar a pilha totalmente.\n"

   "0 - Encerrar o programa.\n");
   }

//FUNÇÃO PARA EMPILHAR OS ELEMENTOS
void empilhando(tipo_proc elemento)
{
if (pilha.topo == tamanho) {
printf("A pilha está cheia, impossivel empilhar!");
system("pause");
}

else {
pilha.dados[pilha.topo] = elemento;
pilha.topo++;

}
}

//FUNÇÃO PARA DESEMPILHAR OS ELEMENTOS
tipo_proc desempilhando()
{
tipo_proc elemento;
if (pilha.ini == pilha.topo) {
printf("A pilha está vazia, impossivel desempilhar!\n");
system("pause");
}
else {
elemento = pilha.dados[pilha.topo];
for(int i=0; i<tamanho; i++)
pilha.dados[pilha.topo]=elemento;
pilha.topo--;
return elemento;
}
}

// FUNÇÃO PARA ESVAZIAR A PILHA

void esvaziar_pilha()
{

int i;

if (pilha.topo == pilha.ini) {
printf("A pilha esta vazia, impossivel esvaziar!\n\n");
system("pause");
}

else {

for (i = 0; i < tamanho; i++)
{
pilha.dados[pilha.topo];
pilha.topo--;
}
}
}

int main()
{
setlocale(LC_ALL, "Portuguese");
pilha.topo = 0;
pilha.ini = 0;
tipo_proc processo;
processo.PID = 0;
tipo_proc backup;

op = 1;
while(op != 0){
printf("\n ---------------------* Pilha *----------------------- \n");


printf("1 - Adicionar elemento na pilha.\n");
printf("2 - Excluir elemento da pilha.\n");
printf("3 - Esvaziar a pilha totalmente.\n");
printf("0 - Encerrar o programa.\n");
printf("S. sair \n");

   printf("\nEscolha sua opcao: ");

   scanf("%d", &op);

switch (op)
{

case 1 :
printf("\nInsira o nome do processo:\n");
   scanf("%s",&processo.nome);

empilhando(processo); //metodo que empilha;

printf("\nDado da pilha:\n");
   printf("PID: %d - Nome: %s\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );

break;

case 2 :

   backup = desempilhando();
       printf("\nConteudo desempilhado:\n");
   printf("PID: %d - Nome: %s\n",backup.PID,backup.nome);
                   desempilhando();

break;

case 3 :

esvaziar_pilha(); //metodo que esvazia

break;

}
}
printf("\nInsira o nome do processo:\n");
scanf("%s",&processo.nome);
fflush(stdin);

empilhando(processo);

printf("\n dados da pilha \n");
printf("PID : %d - nome :%s\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );

}

Flávio Pedroza · 31 de maio de 2019

void mostrar_pilha()
{
    int i;
    printf("\nSua pilha: \n\n");
    for (i = 0; i < pilha.topo; i++) {
         printf("%d %s\n", pilha.dados[i].PID, pilha.dados[i].nome);
         
    }
}
                               
(...)
            switch (op)
            {
              case 1 :
                printf("Digite o elemento a ser empilhado: \n");  
                scanf("%s", processo.nome);
                empilhando(processo); //metodo que empilha;
                processo.PID ++;
              break;

@argolo.david

amigo da Uni · 31 de maio de 2019

amigos, conseguio gerar o PID, mas não esta empilhado corretamente, vejam. temos pouco tempo pra enviar

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

// DEFININDO O TAMANHO

#define tamanho 5

//DECLARANDO A ESTRUTURA

typedef struct t_proc {
char nome[10];
int PID;
} t_proc;

typedef struct t_pilha {
t_proc dados [tamanho];
int topo;
int ini;
} t_pilha;
t_pilha pilha;
t_proc backup;
//FUNÇÃO PARA EMPILHAR OS ELEMENTOS

void empilha(t_proc elemento){
if (pilha.topo == tamanho) {
printf("A pilha está cheia!");
system("pause");
}
else {
pilha.dados[pilha.topo] = elemento;
pilha.topo++;
}
}
//FUNÇÃO PARA DESEMPILHAR OS ELEMENTOS
t_proc desempilha()
{
   int i;
    t_proc elemento;

if (pilha.ini == pilha.topo) {
printf("A pilha está vazia!\n");
system("pause");
}
else {
elemento = pilha.dados[pilha.topo];
       for(i=0; i<tamanho; i++);

           pilha.topo--;
       elemento = pilha.dados[pilha.topo];

return elemento;
}
}
//FUNÇÃO DE RETORNO PARA MOSTRAR A PILHA

void mostrar_pilha(){
char i;
   t_proc processos;
for (i = 0; i < tamanho; i++) {
   printf("\nProcessos Empilhados: \n\n");
printf("%d\n", pilha.dados);
}
//printf("\n\n");
}
void esvaziar_pilha()
{
int i;
if (pilha.topo == pilha.ini) {
printf("A pilha está vazia!\n\n");
system("pause");
}
else {
for (i = 0; i < tamanho; i++)
{
pilha.dados[pilha.topo];
pilha.topo--;
}
}
}

int main(){
    int cm; //conta menu
   do{
setlocale(LC_ALL, "Portuguese");
pilha.topo = 0;
pilha.ini = 0;
printf(" [1] Inserir um novo elemento.\n");
printf(" [2] Remover elemento do Topo.\n");
printf(" [3] Esvaziar a pilha.\n");
   printf(" [4] Mostrar Pilha\n"); ;
printf(" [0] Encerrar.\n");
fflush(stdin);
scanf ("%d",&cm);
switch (cm){
case 1 :
       t_proc processo;
       processo.PID ++;
       printf("\nInsira o nome do processo:\n");
       scanf("%s",&processo.nome);
       fflush(stdin);
       empilha(processo);
       printf("\n -Dados da Pilha.\n");
       printf("PID : %d - nome :%s\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome);
       scanf("PID: %d - Nome: %s", processo.PID, processo.nome);
break;
case 2 :
       desempilha;
       processo = desempilha();
       printf("\nConteúdo que foi desempilhado:\n");
       printf("PID: %d - Nome: %s\n", processo.PID, processo.nome);
break;
   case 3:
       esvaziar_pilha();
   break;
   case 4:
       mostrar_pilha();
   break;
}
}while (cm >0);
return 0;
}

adicionado 0 minutos depois

so que gera o PID a partir do 1 e não do 0.

isso que to me batendo aqui.

adicionado 1 minuto depois

Wagner, ta feio o negocio.

adicionado 4 minutos depois

Quem achar a solução, nos ajude. Please.

Roger Albuquerque · 31 de maio de 2019

O meu ele está gerando mas já esta aparecendo o próximo nó então fica um a mais na lista e os outros comandos as vezes funcionam outras não.

#include <stdlib.h>
#include <stdio.h>
#include <locale.h>
#include <string.h>
#include <iostream>
#include <iomanip>

// DEFININDO O TAMANHO
#define tamanho 5

//DECLARANDO A ESTRUTURA
typedef struct tipo_proc {
char nome[10];
int PID;
} tipo_proc;

typedef struct tipo_pilha {
tipo_proc dados [tamanho];
int topo;
int ini;
} tipo_pilha;

// VARIÁVEIS GLOBAIS
tipo_pilha pilha;
int op;

//FUNÇÃO DE RETORNO PARA MOSTRAR A PILHA
void mostrar_pilha()
{
int i;
printf("\nSua pilha: \n\n");
for (i = 0; i < pilha.topo; i++) {
printf("%d %s\n", pilha.dados.PID, pilha.dados.nome);

}
}

// FUNÇÃO DE RETORNO PARA RETORNAR O MENU

void mostrar_menu()
{

printf("\n\n1 - Adicionar elemento na pilha.\n"

"2 - Excluir elemento da pilha.\n"

"3 - Esvaziar a pilha totalmente.\n"

"0 - Encerrar o programa.\n");
}

//FUNÇÃO PARA EMPILHAR OS ELEMENTOS
void empilhando(tipo_proc elemento)
{

if (pilha.topo == tamanho) {
printf("A pilha está cheia, impossivel empilhar!");
system("pause");
}

else {
pilha.dados[pilha.topo] = elemento;

pilha.topo++;

}
}

//FUNÇÃO PARA DESEMPILHAR OS ELEMENTOS
tipo_proc desempilhando()
{
tipo_proc elemento;
if (pilha.ini == pilha.topo) {
printf("A pilha está vazia, impossivel desempilhar!\n");
system("pause");
}
else {
elemento = pilha.dados[pilha.topo];
for(int i=0; i<tamanho; i++)
pilha.dados[pilha.topo]=elemento;
pilha.topo--;
return elemento;
}
}

// FUNÇÃO PARA ESVAZIAR A PILHA

void esvaziar_pilha()
{

int i;

if (pilha.topo == pilha.ini) {
printf("A pilha esta vazia, impossivel esvaziar!\n\n");
system("pause");
}

else {

for (i = 0; i < tamanho; i++)
{
pilha.dados[pilha.topo];
pilha.topo--;
}
}
}

int main()
{

setlocale(LC_ALL, "Portuguese");
pilha.topo = 0;
pilha.ini = 0;
tipo_proc processo;
processo.PID = 0;
tipo_proc backup;
int i;

op = 1;
while(op != 0){
printf("\n ---------------------* Pilha *----------------------- \n");


printf("1 - Adicionar elemento na pilha.\n");
printf("2 - Excluir elemento da pilha.\n");
printf("3 - Esvaziar a pilha totalmente.\n");
printf("0 - Encerrar o programa.\n");
printf("S. sair \n");

printf("\nEscolha sua opcao: ");

scanf("%d", &op);

switch (op)
{

case 1 :
printf("\nInsira o nome do processo:\n");

           scanf("%s",&processo.nome);

empilhando(processo); //metodo que empilha;

printf("\nDado da pilha:\n");

   for (i = 0; i <= pilha.topo; i++){

                printf("PID: %d - Nome: %s\n",i,pilha.dados.nome );

       }
break;

case 2 :

backup = desempilhando();
printf("\nConteudo desempilhado:\n");
printf("PID: %d - Nome: %s\n",backup.PID,backup.nome);
desempilhando();

break;

case 3 :

esvaziar_pilha(); //metodo que esvazia

break;

}
}
printf("\nInsira o nome do processo:\n");
scanf("%s",&processo.nome);
empilhando(processo); //metodo que empilha;
processo.PID ++;
fflush(stdin);

empilhando(processo);

printf("\n dados da pilha \n");
printf("PID : %d - nome :%s\n\n",pilha.dados[pilha.ini].PID,pilha.dados[pilha.ini].nome );