Ir ao conteúdo
  • Cadastre-se
pilha da depressão

C pilha estatica tan complicado

Posts recomendados

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

Compartilhar este post


Link para o post
Compartilhar em outros sites
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.

Compartilhar este post


Link para o post
Compartilhar em outros sites
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;
}

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Compartilhar este post


Link para o post
Compartilhar em outros sites

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.

Compartilhar este post


Link para o post
Compartilhar em outros sites

sim , hehehe

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Compartilhar este post


Link para o post
Compartilhar em outros sites

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>

Compartilhar este post


Link para o post
Compartilhar em outros sites

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.

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

        }
    }

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

}
 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Acrescenta essas linhas:

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

Deve funcionar agora.

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

image.png.52acd4ade912b8f3ce402d6efaeac5e0.png

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

}
 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites
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

Compartilhar este post


Link para o post
Compartilhar em outros sites

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.

Compartilhar este post


Link para o post
Compartilhar em outros sites

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.

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Compartilhar este post


Link para o post
Compartilhar em outros sites

Esse problema acabei de arrumar o valor excedido.

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

 

adicionado 0 minutos depois

passe pra nós amigo

o trecho

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Aparentemente o meu código agora esta rodando bem.

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

mostrar a pilha tambem acabei de corrigir.

vou mandar o trecho

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

GRÁTIS: minicurso “Como ganhar dinheiro montando computadores”

Gabriel TorresGabriel Torres, fundador e editor executivo do Clube do Hardware, acaba de lançar um minicurso totalmente gratuito: "Como ganhar dinheiro montando computadores".

Você aprenderá sobre o quanto pode ganhar, como cobrar, como lidar com a concorrência, como se tornar um profissional altamente qualificado e muito mais!

Inscreva-se agora!