Ir ao conteúdo
  • Cadastre-se
Ronald Tavares

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

Posts recomendados

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

}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

 

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

clubedo.PNG.d21f02ec76861d60c4698118152f3a9c.PNG

Compartilhar este post


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

 

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

@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

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Trab1.png

Compartilhar este post


Link para o post
Compartilhar em outros sites

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.

 

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

}

 

trab2.png

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

Compartilhar este post


Link para o post
Compartilhar em outros sites

É 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

Compartilhar este post


Link para o post
Compartilhar em outros sites

@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

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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 :(

Compartilhar este post


Link para o post
Compartilhar em outros sites

@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 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

@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 

Compartilhar este post


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

Compartilhar este post


Link para o post
Compartilhar em outros sites

@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

Compartilhar este post


Link para o post
Compartilhar em outros sites

acho que não vai responder mesmo :D

 

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?

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

@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 

Compartilhar este post


Link para o post
Compartilhar em outros sites

 

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

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

@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 

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Compartilhar este post


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

 

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

 

javaweb-popup.jpg

CURSO ONLINE DE PROGRAMAÇÃO
FULL STACK

Entre para o mercado que paga mais de R$ 12.000 por mês e não tem crise!

CLIQUE AQUI E INSCREVA-SE AGORA MESMO!