C++ Código em C++, Pilhas

22 de maio de 2020

Ola Estou Estudando Pilhas, porém estou com duvida referente ao código abaixo, era pra fazer uma Pilha com os valores 1,2,3,4,5,6,7,8 e em outra pilha colocar os valores que saiu dessa primeira Pilha que seria 8,7,6,5,4,3,2,1, portanto eu fiz o código e da um Erro 250, queria ajuda pra ver o que estou fazendo de errado.

  int  elemento1[10];  // vetor que irá armazenar os elementos da pilha

  int  elementos;  // indicador do tamanho da pilha  

};

//----------------------------

// DECLARA AS FUNÇÕES

// ---------------------------

bool empilha(int valor,pilha *mystack );   // insere elementos na pilha

int desempilha(struct pilha *mystack );   // retira elemento da pilha

void imprimepilha(pilha *mystack );    // imprime a pilha

//----------------------------

// INICIO DO PROGRAMA

// ---------------------------

int main( ) {

   struct pilha pilha1;        // Declara a primeira pilha

   struct pilha pilha2;        // Declara a segunda pilha

   pilha1.elementos = pilha2.elementos = 0; // inicializa as pilhas.

   

// ADICIONA ELEMENTOS À PILHA 1

empilha(1,&pilha1);   // Chama a função empilha

empilha(2,&pilha1);   // o primeiro argumento é o numero a adicionar

   empilha(3,&pilha1);   // o segundo argumento é o endereço da pilha

   empilha(4,&pilha1);

   empilha(5,&pilha1);

   empilha(6,&pilha1);

   empilha(7,&pilha1);

   empilha(8,&pilha1);

imprimepilha(&pilha1);  // Chama a função imprimepilha. Argumento é o endereço da pilha



// DESEMPILHA ELEMENTOS DA PILHA 1, PASSANDO PARA PILHA 2

empilha(desempilha(&pilha1),&pilha2);  // desempilha da pilha 1, e empilha na pilha 2

empilha(desempilha(&pilha1),&pilha2); // o primeiro argumento é a função desempilha, que

empilha(desempilha(&pilha1),&pilha2); // desempilha o numero da pilha 1

empilha(desempilha(&pilha1),&pilha2); // o segundo argumento é o endereço da pilha 2

empilha(desempilha(&pilha1),&pilha2); // seria possivel fazer isso usando uma variavel

empilha(desempilha(&pilha1),&pilha2); // intermediaria para armazenar o valor desempilhado

empilha(desempilha(&pilha1),&pilha2); // da pilha1 antes de empilhar na pilha2

empilha(desempilha(&pilha1),&pilha2); //  

   imprimepilha(&pilha2);   // Chama a função imprimepilha. Argumento é o endereço da pilha    

return 0;

}

//----------------------------

// LISTA DE FUNÇÕES

// ---------------------------

//--------------------------------------------

// FUNÇÃO EMPILHA - ADICIONA NUMERO A PILHA

// -------------------------------------------

bool empilha(int valor,pilha *mystack) { // retorna TRUE se adicionou, e FALSE se erro



if (mystack->elementos==100) // se já estiver no tamanho máximo da pilha: 100 elementos

 {

  printf("Tamanho máximo da pilha excedido.\n"); // stack overflow

  return false; // Retorna mensagem de erro ao chamador da função

 }

mystack->elemento1[mystack->elementos]=valor; // adiciona o valor ao vetor da pilha

mystack->elementos++;      //  atualiza numero de elementos  

   //printf( "Elementos : %d\n", mystack->elementos);

   //printf( "Elemento incluido: %d\n\n", valor);

   return true; // retorna mensagem de sucesso  

}

//----------------------------------------------

// FUNÇÃO DESEMPILHA - RETIRA NUMERO A PILHA

// ---------------------------------------------

int desempilha(pilha *mystack ) { // retorna o valor retirado da pilha e -1 se erro.  

if (mystack->elementos==0) // pilha vazia  

 {

  printf("Nao ha elementos na pilha.\n"); // pilha zerada

  return -1; // Retorna mensagem de erro ao chamador da função

 }

mystack->elementos--; //  atualiza numero de elementos. Nao há necessidade de editar o vetor.

   //printf( "Elementos : %d\n", mystack->elementos);

   return mystack->elemento1[mystack->elementos]; // retorna elemento desempilhado.  

}

// -----------------------------------------------------

// FUNÇÃO IMPRIMEPILHA - para gerar o output da tarefa.  

// -----------------------------------------------------

void imprimepilha(pilha *mystack )

{      

if (mystack->elementos==0) // pilha vazia  

 {

  printf("Nao ha elementos na pilha.\n"); // pilha zerada, mensagem de erro

  return;         // retorna a main

 }

for (int i=0;i<mystack->elementos;i++)  // Estrutura de repetição, corre os elementos do vetor

 printf( "%d ", mystack->elemento1[i]); // imprime o numero, e segue um espaço " ".

   printf("\n");        // enter no final

return;          // retorna a main

}

Nêmesis_ · 22 de maio de 2020

Olá@Ronald Tavares , eu peguei seu código e fui fazendo ajustes e acabei nem me ligando o que gerou o erro, exceto algumas declarações.

Bem, crie 3 arquivos main.cpp, pilhas.c. pilhas.h

Postarei o que fiz em cada um deles aqui:

O que modifiquei, sua redeclaração, quando chama struct pilha pilha1, remova struct, pois eu defini ela em pilhas.h;

"inline" no pilhas.cpp;

Acho que deveria ter explicado melhor, eu rodei aqui e funcionou, fiz correndo.

main.cpp

#include "pilhas.cpp"


int main() {

    pilha pilha1;       
    pilha pilha2;        
    pilha1.elementos = pilha2.elementos = 0; // inicializa as pilhas.

    empilha(1, &pilha1);   
    empilha(2, &pilha1);   
    empilha(3, &pilha1);   
    empilha(4, &pilha1);
    empilha(5, &pilha1);
    empilha(6, &pilha1);
    empilha(7, &pilha1);
    empilha(8, &pilha1);

    imprimepilha(&pilha1);  // Chama a função imprimepilha. Argumento é o endereço da pilha

    empilha(desempilha(&pilha1), &pilha2);  // desempilha da pilha 1, e empilha na pilha 2
    empilha(desempilha(&pilha1), &pilha2); // o primeiro argumento é a função desempilha, que
    empilha(desempilha(&pilha1), &pilha2); // desempilha o numero da pilha 1
    empilha(desempilha(&pilha1), &pilha2); // o segundo argumento é o endereço da pilha 2
    empilha(desempilha(&pilha1), &pilha2); // seria possivel fazer isso usando uma variavel
    empilha(desempilha(&pilha1), &pilha2); // intermediaria para armazenar o valor desempilhado
    empilha(desempilha(&pilha1), &pilha2); // da pilha1 antes de empilhar na pilha2
    empilha(desempilha(&pilha1), &pilha2); //  

    imprimepilha(&pilha2);   // Chama a função imprimepilha. Argumento é o endereço da pilha    

    system("pause");

    return 0;

}

pilhas.cpp

#include "pilhas.h"

inline bool empilha(int valor, pilha *mystack) { // retorna TRUE se adicionou, e FALSE se erro

    if (mystack->elementos == 100) // se já estiver no tamanho máximo da pilha: 100 elementos
    {
        printf("Tamanho máximo da pilha excedido.\n"); // stack overflow
        return false; // Retorna mensagem de erro ao chamador da função
    }

    mystack->elemento1[mystack->elementos] = valor; // adiciona o valor ao vetor da pilha
    mystack->elementos++;      //  atualiza numero de elementos  

    return true; // retorna mensagem de sucesso  

}


inline int desempilha(pilha *mystack) { // retorna o valor retirado da pilha e -1 se erro.  

    if (mystack->elementos == 0) // pilha vazia  
    {
        printf("Nao ha elementos na pilha.\n"); // pilha zerada
        return -1; // Retorna mensagem de erro ao chamador da função
    }

    mystack->elementos--; //  atualiza numero de elementos. Nao há necessidade de editar o vetor.
    return mystack->elemento1[mystack->elementos]; // retorna elemento desempilhado.  

}

inline void imprimepilha(pilha *mystack)
{
    if (mystack->elementos == 0) // pilha vazia  
    {
        printf("Nao ha elementos na pilha.\n");
            return;
    }
    for (int i = 0; i < mystack->elementos; i++)
        printf("%d ", mystack->elemento1[i]);

    printf("\n");

    return;

}

pilhas.h

#include <iostream>

typedef struct pilha {

    int elemento1[10];
    int elementos;

}pilha;

bool empilha(int valor, pilha *mystack);   // insere elementos na pilha

int desempilha(pilha *mystack);   // retira elemento da pilha

void imprimepilha(pilha *mystack);    // imprime a pilha

arfneto · 22 de maio de 2020

59 minutos atrás, Ronald Tavares disse:

portanto eu fiz o código e da um Erro 250

podia dizer o que é erro 250, em que ambiente...

Está de fato usando C++ ou C?

Pode postar o enunciado e o programa todo?

Acho que não deve usar void em inicia mas sim retornar o endereço da pilha na função que empilha.

22 de maio de 2020

@Nêmesis_ Ola Boa Noite eu não entendi as funções separadas eu coloco o codigo no Dev C++ e não dá certo, poderia me explicar melhor

arfneto · 22 de maio de 2020

Entendeu o que eu expliquei? pode dizer o que é o erro e postar seu programa como está agora?

23 de maio de 2020

@arfneto Essa é minha duvida, está dando esse Erro do código que eu está em cima

arfneto · 23 de maio de 2020

parece ter uns caracteres invalidos no programa.

Tente digitar de novo por exemplo perto da declaracao de pilha e veja se é isso.

Tire esses acentos dos comentarios. Não ajuda em nada e só pode dar problema. Isso não é importante.

Aqui importa criar as pilhas.

Defina uma estrutura unica e declare duas instâncias. É C++. É mais fácil se fizer assim.

23 de maio de 2020

@arfneto Certo vou refazer o código

adicionado 1 minuto depois

@arfneto Certo pode explicar ou mostrar como fica o código usando o exemplo que você está falando "Defina uma estrutura unica e declare duas instâncias. É C++. É mais fácil se fizer assim "

arfneto · 23 de maio de 2020

Leu o que eu te disse sobre retornar o endereço da pilha ao adicionar?

poste o código como está agora porque assim é mais fácil de eu te mostrar

23 de maio de 2020

@arfneto Certo esse é o codigo

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


int  elemento1[10]; 

int  elementos;  



bool empilha(int valor,pilha *mystack );   

int desempilha(struct pilha *mystack );   

void imprimepilha(pilha *mystack );  


int main( ) {

   struct pilha pilha1;        

   struct pilha pilha2;        

   pilha1.elementos = pilha2.elementos = 0; 

   

	
	empilha(1,&pilha1);   

	empilha(2,&pilha1);   

	empilha(3,&pilha1);  

   empilha(4,&pilha1);

   empilha(5,&pilha1);

   empilha(6,&pilha1);

   empilha(7,&pilha1);

   empilha(8,&pilha1);

imprimepilha(&pilha1);  





empilha(desempilha(&pilha1),&pilha2);  

empilha(desempilha(&pilha1),&pilha2); 

empilha(desempilha(&pilha1),&pilha2);

empilha(desempilha(&pilha1),&pilha2); 

empilha(desempilha(&pilha1),&pilha2);

empilha(desempilha(&pilha1),&pilha2); 

empilha(desempilha(&pilha1),&pilha2); 

empilha(desempilha(&pilha1),&pilha2); 

   imprimepilha(&pilha2);   

return 0;

}


bool empilha(int valor,pilha *mystack) { 


if (mystack->elementos==100) 

 {

  printf("Tamanho máximo da pilha excedido.\n"); 

  return false; 

 }

mystack->elemento1[mystack->elementos]=valor; ]
mystack->elementos++;     
  
  

   return true; 

}



int desempilha(pilha *mystack ) { 

if (mystack->elementos==0)   

 {

  printf("Nao ha elementos na pilha.\n"); 

  return -1; 

 }

mystack->elementos--; 

   return mystack->elemento1[mystack->elementos];  

}


void imprimepilha(pilha *mystack )

{      

if (mystack->elementos==0) 

 {

  printf("Nao ha elementos na pilha.\n"); 

  return;       
 }

for (int i=0;i<mystack->elementos;i++) 

 printf( "%d ", mystack->elemento1[i]);

   printf("\n");  
      
return;         

}

adicionado 1 minuto depois

@arfneto Sobre esse retorno que você está falando eu tiro o void e coloco o que ? não to entendo essa parte

arfneto · 23 de maio de 2020

É de fato um programa em C++? Seu curso é sobre C++ ou estruturas de dados? Tem um livro texto? Qual é? Tem algum livro?

Está um pouco longe do modo recomendado. E de funcionar eu acho. Vou ver mais agora

23 de maio de 2020

@arfneto è sobre estrutura de dados, O trabalho e fazer um código que contenha 2 pilha uma com o valor 1 2 3 4 e a segunda pilha precisa ter os valores da primeira só que invertido 4 3 2 1

arfneto · 23 de maio de 2020

Em C++?

Tem um livro texto? Qual é? Tem algum livro?

Está um pouco longe do modo recomendado. E de funcionar eu acho. Vou ver mais agora

Você sequer declarou a struct pilha

23 de maio de 2020

@arfneto Tem o Livro que a faculdade disponibilizou, o Livro está arquivado

Estrutura_de_dados.pdf

adicionado 1 minuto depois

@arfneto Só que estou com muitas duvida nessa parte de declarar as 2 pilhas e os dados que ta em uma passar pra outra

arfneto · 23 de maio de 2020

E de C++ não tem uma referência? Nada?

C++ por exemplo tem pilhas prontas. E filas e árvores e o d$%bo. Então muitas vezes é mais simples olhar o que tem lá e replicar, porque certamente aquilo funciona.

Você pode declarar algo para a pilha, bem mínimo, assim


struct Pilha
{
	int p[10];
	int capacidade;
	int posicao;

	Pilha() : capacidade(10), posicao(0) {};

	int      desempilha();
	bool     empilha();
	int      imprimePilha();
};

Assim quando cria uma pilha ela já sabe que cabem 10 caras e está vazia. Não precisa fazer nada. É um exemplo simples demais, mas o enunciado é assim.

Precisa de duas pilhas ou de 200 tanto faz


Pilha primeira, segunda; // duas pilhas vazias, já com 10 posições.
Pilha pilhas[200]; // 200 pilhas. nao faz diferenca: um vetor delas

23 de maio de 2020

@arfneto Certo essa Parte eu consegui Entender agora referente ao código que atribui os valores nessa pilha eu quero colocar 1 2 3 4 5 6 7 8 e passar para segunda a pilha os valores 8 7 6 5 4 3 2 1, Poderia me ajudar nessa parte

adicionado 0 minutos depois

@arfneto Ou eu consigo usar aquela mesma função do primeiro código

arfneto · 23 de maio de 2020

2 minutos atrás, Ronald Tavares disse:

Ou eu consigo usar aquela mesma função do primeiro código

Você está entendendo...

Assim é. O código faz parte da pilha.

adicionado 1 minuto depois

7 minutos atrás, arfneto disse:

E de C++ não tem uma referência? Nada?

C++ por exemplo tem pilhas prontas. E filas e árvores e o d$%bo. Então muitas vezes é mais simples olhar o que tem lá e replicar, porque certamente aquilo funciona.

E sobre isso? não respondeu...

23 de maio de 2020

@arfneto Certo, então como ficaria o código com a função que você acabou de fazer, poderia me dar um Exemplo.

adicionado 7 minutos depois

@arfneto São em C++, Referencias não tem

adicionado 10 minutos depois

Tem vários códigos de pilha que eu procurei, porém eu queria saber como fazer para inserir dados fixos tipo 1,2,3,4,5,6 e passar para uma segunda pilha, porém os códigos que eu acho são mais complexos, e como eu não tenho muito entendimento sobre pilhas, não consigo modificar para deixar do jeito que é preciso

arfneto · 23 de maio de 2020

acho que não vai responder mesmo

não "fiz uma função"

O que eu te mostrei é uma declaração de uma struct, uma classe na terminologia C++. Podia ter declarado class ao invés de struct

Atente para a declaração: ao declarar uma pilha ela já aparece com uma capacidade e vazia e com um ponteiro para o próximo elemento e tal. Vem de fábrica.

	Pilha() : capacidade(10), posicao(0) {};

Quando você declara uma pilha o sistema vai rodar esse código aí e definir o que está aí e o que mais você colocar entre as chaves, como em C. Só que a gente não precisa de nada mais então ficaram só as chaves mesmo.

Empilhar, por exemplo, seria algo como

se a pilha está cheia retorna falso. Como sabe que ela está cheia? Bem besta, porque tem a capacidade de 10 e a posição para marcar onde vai colocar o próximo. No entanto a posição começa de zero
Se não está cheia você coloca o valor lá e retorna ok, true.

O código, por exemplo:

bool Pilha::empilha(int valor)
{	// pode nao caber
	if (posicao > (capacidade - 1)) return false;
	p[posicao] = valor;
	posicao = posicao + 1;
	return true;
}

Só isso. Quando não couber mais retorna false e não tem outra razão pra dar erro então

	Pilha um;
	um.imprime();

	int valor = -10;
	while( um.empilha(valor) )
		valor = valor + 1;

	um.imprime();

vai encher a pilha todinha e imprimir

pilha vazia
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1

Ou algo assim dependendo de como escreveu imprime()

adicionado 2 minutos depois

Entendeu o mecanismo?

23 de maio de 2020

@arfneto Olha e que assim referente a essa matéria eu estou bem perdido por isso pedi ajuda , pois o livro não tem muita definição de como fazer uma pilha, ai eu queria saber como ficaria o código completo dessa função, pois todos os códigos que eu fiz está dando os mesmo erros, por eu não ter muito conhecimento referente a C++ eu queria pedir ajuda a isso, como ficaria um código inteiro sei que estou pedindo muito e você não tem obrigação de me ajuda mais e que referente a isso eu estou bem perdido

mais essa parte de Inserir Tirar elementos eu entendi o conceito só que eu me perco na hora de criar as varias e dar continuidade ao código

arfneto · 23 de maio de 2020

Eu te mostrei como fazer uma. Bem simples na verdade. Mas o enunciado é assim

O programa é só isso mesmo. Só não tinha o código da imprime, que pode ser só

	if (posicao == 0)
	{	cout << "pilha vazia" << endl;
		return 0;
	};
	// ok tem gente
	for (int i = 0; i < posicao; i = i + 1)
		cout << p[i] << " ";
	cout << endl;

E o programa é só juntar o que escrevi

#include <iostream>

using namespace std;

struct Pilha
{
	int p[10];
	int capacidade;
	int posicao;

	Pilha() : capacidade(10), posicao(0) {};

	int      desempilha();
	bool     empilha(int);
	int      imprime();
};

int main(int argc, char** argv)
{
	Pilha um;
	um.imprime();

	int valor = -10;
	while (um.empilha(valor))
		valor = valor + 1;

	um.imprime();

	return 0;
}

int Pilha::desempilha()
{
	return 0;
}

bool Pilha::empilha(int valor)
{	// pode nao caber
	if (posicao > (capacidade - 1)) return false;
	p[posicao] = valor;
	posicao = posicao + 1;
	return true;
}

int Pilha::imprime()
{
	if (posicao == 0)
	{
		cout << "pilha vazia" << endl;
		return 0;
	};
	// ok tem gente
	for (int i = 0; i < posicao; i = i + 1)
		cout << p[i] << " ";
	cout << endl;
	return 0;
}

23 de maio de 2020

@arfneto Certo esse foi o único código que deu certo, ai eu queria saber como eu coloco os dados que eu quero na pilha 1 e mandar para uma outra pilha

arfneto · 23 de maio de 2020

A pilha tem essas 3 funções --- são chamadas métodos --- e cada pilha que você declara vem com esses métodos. E o Pilha() aquele que cria a pilha, e é chamado construtor.

Recomendo muito um livro para aprender C++. É uma linguagem enorme e complexa..

Entenda que tem um problema com esse enunciado: como desempilha retorna um int e a pilha está cheia deles como você vai saber se desempilhou algo?

Ou usa um marcador, tipo um valor impossível, ou uma função que diz se ela está vazia e esta, ou sei lá...

23 de maio de 2020

@arfneto Tipo o código base eu entendi o que eu tenho mais duvida e essa troca de valores.

arfneto · 23 de maio de 2020

1 minuto atrás, Ronald Tavares disse:

Certo esse foi o único código que deu certo, ai eu queria saber como eu coloco os dados que eu quero na pilha 1 e mandar para uma outra pilha

Acabei de escrever pra te explicar. Eu sei que está certo.

Precisa resolver o problema que te expliquei... como saber que desempilhar não rolou?

adicionado 0 minutos depois

1 minuto atrás, Ronald Tavares disse:

Tipo o código base eu entendi o que eu tenho mais duvida e essa troca de valores

agora eu não entendi. que troca?

Entrar

C++ Código em C++, Pilhas

Posts recomendados

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

Link para o comentário

Compartilhar em outros sites

Crie uma conta ou entre para comentar

Criar uma conta

Entrar

Quem está navegando aqui 0 usuários estão online

Últimos tópicos

Livros

Cursos

Conteúdo recente

Sobre o Clube do Hardware

Direitos autorais

Mais