C pilha estatica tan complicado

[pilha da depressão]

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]

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]

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]

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]

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

[kode v]

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]

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

[kode v]

sim , hehehe

[przinho]

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

[kode v]

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]

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]

@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]

@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]

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]

@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]

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]

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]

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]

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 );

}
 

 

Ajuda aee.

[kode v]

@amigo da Uni o PID acho que ta de boa ta gerando uma sequencia, agora o empilha ta deixando adicionar mais de 5 processo.

[Roger Albuquerque]

Esse problema acabei de arrumar o valor excedido.

[amigo da Uni]

sim, to tentando corrigir isso. e mostrar a pilha tirei fora.

 

adicionado 0 minutos depois

passe pra nós amigo

o trecho

 

[Roger Albuquerque]

Aparentemente o meu código agora esta rodando bem.

 

[amigo da Uni]

mostrar a pilha tambem acabei de corrigir.

vou mandar o trecho

 

[kode v]

@GhostGolden posta ai para vemos