Error conversion from `TipoPila**' to non-scalar type `TipoPila' requested

[vnvnation]

Hola que tal bueno estoy a qui programando en Dev C/C++ lo siguiente pero me sale error de conversion from `TipoPila**' to non-scalar type `TipoPila' requested quisiera saber a que se refiere o que esta mal por favor

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 3
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope;
         TipoTope Stack;
          TipoElem Elementos [MAX];
          };
 
int InicializarPila (TipoPila Stack);
int PilaVacia(TipoPila Stack);
int PilaLlena(TipoPila Stack);
  main ()
{
TipoPila *Pila;
int opcion;
TipoElem Elem;
InicializarPila(&Pila);
opcion=0 ;
switch (opcion){
       case 1 :
            InicializarPila(&Pila);
       cout<<"Pila inicializada ...";
       break;
       }   
}
 
int InicializarPila (TipoPila Stack){
Stack.Tope=VACIO;}
 

[dual3nigma]

Creo que seria bueno tambien que comentaras lo que quieres hacer, a lo que se refiere ese error es que estas mandando un (pointer a un pointer a Pila) a una funcion que que no acepta ese tipo:

Código C++:

TipoPila *Pila // Pointer a Pila
InicializarPila(&Pila) // Estas mandando un pointer a
int InicializarPila(TipoPila Stack) // No mencionas para nada TipoPila **Stack que es lo que estas mandando
 

No se en realidad lo que estes tratando de hacer pero hay otros detalles que debes de considerar, que aun si pusieras:

Código C++:

int IniticializarPila(TipoPila **Stack) {
    (*Stack)->Top = VACIO;
    // Fijate tambien que te va a dar error por que no estas regresando nada y la declaracion dice que regresas un valor tipo int
}
 

Ah pues si aun si hicieras eso no te funcionaria puesto que en ningun lugar estas creando el struct TipoPila al que quieres que apunte TipoPila, como te decia no se lo que quieras hacer pero aqui esta mi version de lo que yo entendi que quieres hacer:

Código C++:

#include <iostream.h>
#include <conio.h>
 
#define MAX 3
#define VACIO -1
 
typedef int  TipoTope;
typedef char TipoElem;
 
typedef struct TipoPila {
         TipoTope Tope;
         TipoTope Stack;
         TipoElem Elementos[MAX];
                };
 
int InicializarPila(TipoPila *Stack);
int PilaVacia(TipoPila Stack);
int PilaLlena(TipoPila Stack);
 
int  main () {
    TipoPila Pila;
 
    int opcion;
 
    TipoElem Elem;
 
    InicializarPila(&Pila);
 
    opcion = 0;
 
    switch (opcion) {
        case 1 :
            InicializarPila(&Pila);
            std::cout << "Pila inicializada ...";
        break;
    }
 
    return 0;
}
 
int InicializarPila(TipoPila *Stack) {
    Stack->Tope = VACIO;
    return 0;
}
 

[vnvnation]

Hola bueno si funcono gracias amigo era un error cuando se usa el apuntador * se usa el -> se me paso, ahora quiero ingresar datos a mi pila y sacar e imprimir esos datos con una funcion push y pop me podian ayudar

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 3
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope;
          TipoElem Elementos [MAX];
          };
 
int InicializarPila (TipoPila *Stack);
int PilaVacia(TipoPila *Stack);
int PilaLlena(TipoPila *Stack);
  main ()
{
TipoPila Pila;
int  opcion1=0;
TipoElem Elem;
InicializarPila (&Pila);
PilaVacia(&Pila);
 PilaLlena(&Pila);
 
char opcion=0;
while (opcion1!='s'){
cout << "\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 InicializarPila";
 cout <<"\n2 Pila LLENA";
 cout <<"\n3 Pila VACIA\nOpcion=";
  cin >> opcion1;
 
switch (opcion1){
       case 1:
            InicializarPila(&Pila);
       cout<<"Pila inicializada ...";
       getch ();
       break;
         getch (); 
         
       case 2: 
            PilaLlena(&Pila);
      cout<<"Pila LLENA!!";
      getch ();
      break;
       
      case 3: 
           PilaVacia(&Pila);
      cout<<"Pila VACIA!!";
      getch (); 
      
      break;
          }
           
}}
 
int InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
int PilaLlena(TipoPila *Stack)
{
    return Stack->Tope==MAX;
}
int PilaVacia(TipoPila *Stack)
{
    return Stack->Tope==VACIO;
}
 

[sam90]

no es muy dificil. Cuando haces push sumas una al tope de la pila y guardas el dato en ese valor. Cuando lo sacas restas uno al tope y devuelves el valor que estaba almacenado antes de restar.
Piensalo bien. Cuando tengas algo de codigo postealo que te ayudamos!

[vnvnation]

Bueno tengo esto ya mete y saca valores pero no me inicializa la pila me pueden ayudar plis

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 3
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          };
 
int InicializarPila (TipoPila *Stack);
int push(int *Stackb, int Stack_i[3]);
void pop(int *Stackc, int Stack_e[3]);
  main ()
{
TipoPila Pila1;
int Stack[3];
int   cima=0,opcion1=0;
 
 
while (opcion1!='s')
{
cout << "\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila";
 cout <<"\n2 Ingresar datos a la Pila";
 cout <<"\n3 Sacar datos de la pila\nOpcion=";
  cin >> opcion1;
 
switch (opcion1){
       case 1:
            InicializarPila(&Pila1);
       cout<<"Pila inicializada ...";
       getch ();
       break;
         getch (); 
       case 2: 
         push(&cima, Stack);
      getch ();
      
      break;
      case 3: 
pop(&cima, Stack);
      getch (); 
      
      break;
          }
           
}}
 
int InicializarPila(TipoPila *Stack) 
{
     Stack->Tope==VACIO;
     }
int push(int *Stack, int Stack_i[3])
{   
 if(*Stack==3)
   cout << "\nPila llena!!!!\n";
 else
 {
  cout << "Ingresa el elemento a la pila\n";
  cin >> Stack_i[*Stack];
  *Stack=*Stack+1;
 }
}
void pop(int *Stack, int Stack_e[3])
{
 
 if (*Stack<=0)
 {
  cout << "No hay elementos en la pila\nIngrese  elementos primero:\n";
 }
 else
 {
  *Stack=*Stack-1;
  cout << "\nElemento expulsado de la fila: ";
  cout << Stack_e[*Stack];
 }
 
}
 

[sam90]

No tiene sentido que lo que haces, ya que al inicializarla usas la variable Pila1 del tipo TipoStock.

Pero despues en push y pop te olvidas completamente de esas structura. y utilizas cualquier otra cosa.

Código C++:

int push(TipoPila *Stack, int valor)
{   
 if(Stack->Tope==MAX)
          cout << "\nPila llena!!!!\n";
 else
 {
        Stack->Tope++;
        Stack->Elementos[Stack->Tope] = valor;
 }
}
 

Asi seria el Push, Ahora tratar de hacer el Pop

[vnvnation]

Ya hice el pop era lo mismo que push pero nada mas que en drecremento, ahora el caso es que yo ingrese los elemento a la pila por que al dar enter me ingresa un valor y mi pila se llena este es mi codigo

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 3
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          };
 
int InicializarPila (TipoPila *Stack);
int PilaLlena (TipoPila *Stack);
int Push (TipoPila *Stack, TipoTope valor);
int Pop(TipoPila *Stack, int valor);
  main ()
{
TipoPila Pila;
TipoElem valor;
int   opcion1=0;
//InicializarPila(&Pila);
//Push (&Pila,valor);
 
while (opcion1!='s')
{
cout << "\n\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila";
 cout <<"\n2 Ingresar datos a la Pila";
 cout <<"\n3 Sacar datos de la pila\nOpcion=";
  cin >> opcion1;
 
switch (opcion1){
       case 1:
            InicializarPila(&Pila);
       cout<<"Pila inicializada ...";
       getch ();
       break;
       case 2: 
       Push(&Pila,valor);
       getch (); 
       break;
       case 3: 
       Pop(&Pila,valor);
         getch (); 
 
      
      break;
 
          }
           
}}
 
int InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
 
int Push(TipoPila *Stack, TipoTope valor)
 
{   
 if(Stack->Tope==MAX)
          cout << "\nPila llena!!!!\n";
 else
 {
        Stack->Tope++;
        Stack->Elementos[Stack->Tope] = valor;
 }
}
 
 
int Pop(TipoPila *Stack, int valor)
{   
 if(Stack->Tope==VACIO)
          cout << "\nPila esta vacia ingrese datos primero:";
 else
 {
        Stack->Tope--;
        Stack->Elementos[Stack->Tope] = valor;
 }
}
 

[vnvnation]

Ya pude ingresar datos no se si a si este bien o mal¿?

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 3
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          };
 
int InicializarPila (TipoPila *Stack);
int PilaLlena (TipoPila *Stack);
int Push (TipoPila *Stack, TipoTope valor);
int Pop(TipoPila *Stack, TipoTope valor);
  main ()
{
TipoPila Pila;
TipoElem valor;
int   opcion1=0;
//InicializarPila(&Pila);
//Push (&Pila,valor);
 
while (opcion1!='s')
{
cout << "\n\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila";
 cout <<"\n2 Ingresar datos a la Pila";
 cout <<"\n3 Sacar datos de la pila\nOpcion=";
  cin >> opcion1;
 
switch (opcion1){
       case 1:
            InicializarPila(&Pila);
       cout<<"Pila inicializada ...";
       break;
       case 2: 
       Push(&Pila,valor);
       break;
       case 3: 
       Pop(&Pila,valor);
       break;
 
          }
           
}}
 
int InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
 
int Push(TipoPila *Stack, TipoTope valor)
 
{   TipoElem Elementos;
 if(Stack->Tope==MAX)
          cout << "\nPila llena!!!!\n";
 else
 {
     cout<<"Ingrese elementos a la pila:";
     cin >> Elementos;
        Stack->Tope++;
        Stack->Elementos[Stack->Tope] = valor;
 }
}
 
 
int Pop(TipoPila *Stack, TipoTope valor)
{   
 if(Stack->Tope==VACIO)
          cout << "\nPila esta vacia ingrese datos primero:";
 else
 {
        Stack->Tope--;
        Stack->Elementos[Stack->Tope] = valor;
 }
}
 

[sam90]

No entiendo cual es tu problema...Pero fijate que el pop no tiene que tomar un argumento y modificar la pila. Al contrario debe devolver el valor que estaba en la pila..... Deberias repazar los conceptos de una pila antes de empezar a programarla!

[vnvnation]

Entonces quedaria a si o me equivoco¿? si no avansare a crear mi siguiente funcion de contar e imprimir cuantos elementos tiene mi pila

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 3
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          };
 
int InicializarPila (TipoPila *Stack);
int PilaLlena (TipoPila *Stack);
int Push (TipoPila *Stack, TipoTope valor);
int Pop(TipoPila *Stack);
  main ()
{
TipoPila Pila;
TipoElem valor;
int   opcion1=0;
//InicializarPila(&Pila);
//Push (&Pila,valor);
 
while (opcion1!='s')
{
cout << "\n\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila";
 cout <<"\n2 Ingresar datos a la Pila";
 cout <<"\n3 Sacar datos de la pila\nOpcion=";
  cin >> opcion1;
 
switch (opcion1){
       case 1:
            InicializarPila(&Pila);
       cout<<"Pila inicializada ...";
       system ("pause");
       break;
       case 2: 
       Push(&Pila,valor);
       break;
       case 3: 
       Pop(&Pila);
       system ("pause");
       break;
 
          }
   system ("cls");       
}}
 
int InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
 
int Push(TipoPila *Stack, TipoTope valor)
 
{   TipoElem Elementos;
 if(Stack->Tope==MAX)
          cout << "\nPila llena!!!!\n";
 else
 {
     cout<<"Ingrese elementos a la pila:";
     cin >> Elementos;
        Stack->Tope++;
        Stack->Elementos[Stack->Tope] = valor;
 }
}
 
 
int Pop(TipoPila *Stack)
{   
 if(Stack->Tope==VACIO)
          cout << "\nPila esta vacia ingrese datos primero:\n";
 else
 {
        Stack->Tope--;
       }
}
 

[sam90]

Veo que al push le agregaste una lectura de teclado... pero no la estas utilizando. Yo se la sacaria asi si queres usar la pila en otro programa lo podes usar. Por algo le agregue el argumento llamado valor a la funcion Push.

En el Pop te faltaria que devuelva el valor que estaba almacenado:
return Stack->Elementos[Stack->Tope+1] ;

El +1 va proque va despues de decremetar la variable tope.

[vnvnation]

Entonces seria algo a si o aun esta mal ¿? Regañame si es necesari siii

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 3
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          };
 
int InicializarPila (TipoPila *Stack);
int PilaLlena (TipoPila *Stack);
int Push (TipoPila *Stack, TipoTope valor);
int Pop(TipoPila *Stack);
  main ()
{
       system ("color f9");
TipoPila Pila;
TipoElem valor;
int   opcion1=0;
//InicializarPila(&Pila);
//Push (&Pila,valor);
 
while (opcion1!='s')
{
cout << "\n\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila";
 cout <<"\n2 Ingresar datos a la Pila";
 cout <<"\n3 Sacar datos de la pila\nOpcion=";
  cin >> opcion1;
 
switch (opcion1){
       case 1:
            InicializarPila(&Pila);
       cout<<"Pila inicializada ...\n";
       system ("pause");
       break;
       case 2: 
       Push(&Pila,valor);
       break;
       case 3: 
       Pop(&Pila);
       system ("pause");
       break;
 
          }
   system ("cls");       
}}
 
int InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
 
int Push(TipoPila *Stack, TipoTope valor)
 
{   TipoElem Elementos;
 if(Stack->Tope==MAX){
          cout << "\nPila llena!!!!\n";
          system ("pause");}
 else
 {
     cout<<"Ingrese elementos a la pila:";
     cin >> Elementos;
        Stack->Tope++;
 }
}
 
 
int Pop(TipoPila *Stack)
{   
 if(Stack->Tope==VACIO)
          cout << "\nPila esta vacia ingrese datos primero:\n";
 else
 {
        Stack->Tope--;
        return Stack->Elementos[Stack->Tope+1] ;
       }
}
 

[vnvnation]

Ahora que estoy haciendo mal a qui ¿? no me quiere compilar funcion imprimir y contar

Código C++:

typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          };
 
int InicializarPila (TipoPila *Stack);
int PilaVacia (TipoPila *Stack);
int Push (TipoPila *Stack);
int Pop(TipoPila *Stack);
int Imprimir(TipoPila *Stack);
int contar (TipoPila *Stack);
  main ()
{
       system ("color f9");
TipoPila Pila;
TipoElem Elementos;
int   opcion1=0;
 
while (opcion1!='s')
{
cout << "\n\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila";
 cout <<"\n2 Ingresar datos a la Pila";
 cout <<"\n3 Sacar datos de la pila\nOpcion=";
  cin >> opcion1;
 
switch (opcion1){
       case 1:
            InicializarPila(&Pila);
       cout<<"Pila inicializada ...\n";
       system ("pause");
       break;
       case 2: 
       Push(&Pila);
       break;
       case 3: 
       Pop(&Pila);
       system ("pause");
       break;
       case 4:
       //Imprimir(&Pila);
       case 5:
            contar (&Pila);
          }
   system ("cls");       
}}
 
 
 
int InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
 
int Push(TipoPila *Stack,)
 
{   TipoElem Elementos;
 if(Stack->Tope==MAX){
          cout << "\nPila llena!!!!\n";
          system ("pause");}
 else
 {
     cout<<"Ingrese elementos a la pila:";
     cin >> Elementos;
        Stack->Tope++;
 }
}
 
int Pop(TipoPila *Stack)
{   
 if(Stack->Tope==VACIO)
          cout << "\nPila esta vacia ingrese datos primero:\n";
 else
 {
        Stack->Tope--;
        return Stack->Elementos[Stack->Tope+1] ;
       }
}
 int PilaVacia(TipoPila *Stack)
 {
 return (Stack->Tope==VACIO);
}
 
int Imprimir(TipoPila *Stack)
{
    TipoElem Elementos;
while(!PilaVacia(Stack))
{
       
       Pop (&Stack,&Elementos);
       cout << Elementos;
}      
}
int contar (TipoPila *Stack)
{
    int contador=0;
    TipoPila Aux; 
    TipoElem Elementos;
    InicializarPila (&Aux);
    while(!PilaVacia(Stack)) {
    Pop(*Stack,Elementos),
    contador=contador+1;
    Push(&Aux,Elementos);
    }
    }
 

[sam90]

Primero la funcion pop no toma un segundo argumento. Lo devuelve como resultado.
Lo mismo pasa en la funcion imprimir....
Viendo los errores que estas cometiendo te recomendaria que empieces con algo mas basico.

[vnvnation]

Bueno e cambiado mi codigo un poco pero aun me sale error en imprimir

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 2
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          };
void InicializarPila (TipoPila *Stack);
int PilaLlena(TipoPila *Stack);
int PilaVacia(TipoPila *Stack);
int Push (TipoPila *Stack,TipoElem Elemen);
int Pop (TipoPila *Stack,TipoElem Elemen);
int Imprimir (TipoPila *Stack);
 main ()
{
system ("color f9");
TipoPila Pila;
TipoElem Elementos;
int opcion1=0;
while (opcion1!='s')
{
cout << "\n\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila: \n";
  cout <<"2 Ingresar elementos a la pila: \n";
  cout <<"3 Sacar elementos de la pila: \n";
 cin >> opcion1;
 switch (opcion1)
{
       case 1:
            InicializarPila(&Pila);
       cout<<"Pila inicializada ...\n";
       break;
       case 2:
             if(PilaLlena(&Pila)){
          cout << "\nPila llena!!!!\n";}
           else{
     cout<<"Ingrese elementos a la pila:";
     cin >> Elementos;
     Push(&Pila,Elementos);}
     break;
     case 3:
          if(PilaVacia(&Pila)){
          cout << "\nLa pila esta vacia ingrese elementos primero!!!!\n";
          }
          else{
     Pop(&Pila,Elementos);
     cout <<"\n El elemnto sacado de la pila es: "<<Elementos;
     
     }
     
          break;
          
}}}
//InicializarPila
void InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
//PilaLlena
int PilaLlena(TipoPila *Stack)
{
    return (Stack->Tope==MAX);
}
//PilaVacia
int PilaVacia(TipoPila *Stack)
{
 return (Stack->Tope==VACIO);
}
//Push
int Push (TipoPila *Stack,TipoElem Elemen)
{
return (Stack->Tope++);
 }
 //Pop
int Pop (TipoPila *Stack,TipoElem Elemen)
{
return (Stack->Tope--);
 }
 //Imprimir
 int Imprimir (TipoPila *Stack)
 {
  TipoElem Elemen;
while (!PilaVacia(Stack))
{
       Pop (*Stack,&Elemen);
       cout << Elemen;
}           
      }
 

[sam90]

En la nueva implementacion, el push nunca guarda el elemento en la pila. solo esta modificando en tope. Lo mismo pasa en el pop. Solo bajas en uno el tope y no devolves el valor que habia en la pila.

Corrige esas cosas en la nueva implementacion,

[vnvnation]

Aver esta implementacion esta bien o mal

Código C++:

void Push (TipoPila *Stack,TipoElem *Elemen)
{
 *Elemen=Stack->Elementos[Stack->Tope=++];
  
 }
 //Pop
void Pop (TipoPila *Stack,TipoElem *Elemen)
{
  *Elemen=Stack->Elementos[Stack->Tope--];
  
 }
 

Edito: Creo que esta mal no se pero implemente este otro creo que esta bien no se aun por que no me correo el programa si me lo compila pero me manda un error y se cierra

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 2
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          }Pila;
void InicializarPila (TipoPila *Stack);
int PilaLlena(TipoPila *Stack);
int PilaVacia(TipoPila *Stack);
void Push (TipoPila *Stack,TipoElem Elemen);
int Pop (TipoPila *Stack,TipoElem *Elemen);
int Imprimir (TipoPila Stack);
int Contar (TipoPila *Stack);
 main ()
{
system ("color f9");
TipoPila Pila;
TipoTope Tope;
TipoElem Elementos;
int opcion1=0;
while (opcion1!='s')
{
cout << "\n\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila: \n";
  cout <<"2 Ingresar elementos a la pila: \n";
  cout <<"3 Sacar elementos de la pila: \n";
   cout <<"4 Imprimir elementos de la pila: \n";
   cout <<"5 Contar elementos de la pila: \n";
   cout <<"\n opcion:";
 cin >> opcion1;
 switch (opcion1)
{
       case 1:
            InicializarPila(&Pila);
       cout<<"Pila inicializada ...\n";
       break;
       case 2:
             if(PilaLlena(&Pila)){
          cout << "\nPila llena!!!!\n";}
           else{
     cout<<"Ingrese elementos a la pila:";
     cin >> Elementos;
Push(&Pila,Elementos);}
     break;
     case 3:
          if(PilaVacia(&Pila)){
          cout << "\nLa pila esta vacia ingrese elementos primero!!!!\n";
          }
          else{
     Pop(&Pila,&Elementos);
     cout <<"\n El elemento sacado de la pila es: "<<Elementos;
     }
     break;
    /* case 4:
          cout << Imprimir(Pila);
          break;  
     case 5:
         cout <<  Contar(&Pila);
          
          break;        */
}}getch ();}
//InicializarPila
void InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
//PilaLlena
int PilaLlena(TipoPila *Stack)
{
    return (Stack->Tope==MAX);
}
//PilaVacia
int PilaVacia(TipoPila *Stack)
{
 return (Stack->Tope==VACIO);
}
//Push
void Push (TipoPila *Stack,TipoElem Elemen)
{
 Stack->Tope++;
 Stack->Elementos[Stack->Tope]=Elemen;
  
 }
 //Pop
int Pop (TipoPila *Stack,TipoElem *Elemen)
{   
  
  *Elemen=Stack->Elementos[Stack->Tope];
  Stack->Tope--;
  return *Elemen;
 }
 /*/Imprimir
 int Imprimir (TipoPila Stack)
 {
TipoElem Elementos;
while (!PilaVacia(&Stack))
{
       Pop (&Stack,Elementos);
       cout <<"\n"<<Elementos;
}         
      }
//Contar
int Contar (TipoPila *Stack)
{
 int contador=0;
 TipoPila Aux;
 TipoElem Elementos;  
 InicializarPila (&Aux);
 while (!PilaVacia(Stack))
 {
 Pop(&Stack,&Elementos);
 contador=contador+1;
 Push(&Aux,Elementos);
 
}
}*/
 

Ahora me falta que cuente y que imprima espero no se me complique de nuevo que cren que este mal

[vnvnation]

Bueno el de imprimir ya salio pero no se por que me muestra un 1 al final de del ultimo elemento de mi pila y el de contar aun no lo puedo correr bien

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 2
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          }Pila;
void InicializarPila (TipoPila *Stack);
int PilaLlena(TipoPila *Stack);
int PilaVacia(TipoPila *Stack);
void Push (TipoPila *Stack,TipoElem Elemen);
int Pop (TipoPila *Stack,TipoElem *Elemen);
int Imprimir (TipoPila Stack);
int Contar (TipoPila Stack);
 main ()
{
system ("color f9");
TipoPila Pila;
TipoTope Tope;
TipoElem Elementos;
int opcion1=0;
while (opcion1!='s')
{
cout << "\n\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila: \n";
  cout <<"2 Ingresar elementos a la pila: \n";
  cout <<"3 Sacar elementos de la pila: \n";
   cout <<"4 Imprimir elementos de la pila: \n";
   cout <<"5 Contar elementos de la pila: \n";
   cout <<"\n opcion:";
 cin >> opcion1;
 switch (opcion1)
{
       case 1:
            InicializarPila(&Pila);
       cout<<"Pila inicializada ...\n";
       break;
       case 2:
             if(PilaLlena(&Pila)){
          cout << "\nPila llena!!!!\n";}
           else{
     cout<<"Ingrese elementos a la pila:";
     cin >> Elementos;
Push(&Pila,Elementos);}
     break;
     case 3:
          if(PilaVacia(&Pila)){
          cout << "\nLa pila esta vacia ingrese elementos primero!!!!\n";
          }
          else{
     Pop(&Pila,&Elementos);
     cout <<"\n El elemento sacado de la pila es: "<<Elementos;
     }
     break;
    case 4:
          cout << Imprimir(Pila);
          break;  
      case 5:
         cout <<  Contar(Pila);
          
          break;       
}}getch ();}
//InicializarPila
void InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
//PilaLlena
int PilaLlena(TipoPila *Stack)
{
    return (Stack->Tope==MAX);
}
//PilaVacia
int PilaVacia(TipoPila *Stack)
{
 return (Stack->Tope==VACIO);
}
//Push
void Push (TipoPila *Stack,TipoElem Elemen)
{
 Stack->Tope++;
 Stack->Elementos[Stack->Tope]=Elemen;
  
 }
 //Pop
int Pop (TipoPila *Stack,TipoElem *Elemen)
{   
  
  *Elemen=Stack->Elementos[Stack->Tope];
  Stack->Tope--;
  return *Elemen;
 }
 //Imprimir
 int Imprimir (TipoPila Stack)
 {
TipoElem Elementos;
while (!PilaVacia(&Stack))
{
       Pop (&Stack,&Elementos);
       cout <<"\n"<<Elementos;
}         
      }
//Contar
int Contar (TipoPila Stack)
{
 int contador=0;
 TipoPila Aux;
 TipoElem Elementos;  
 InicializarPila (&Aux);
 while (!PilaVacia(&Stack))
 {
 Pop(&Stack,&Elementos);
 contador=contador+1;
 Push(&Aux,Elementos);
 
}
}
 

Edito

Creo que ya cuenta pero no se muy bien creo que hai un error por que tambien me aparece un 1 al fial de mi conteo

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 2
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          }Pila;
void InicializarPila (TipoPila *Stack);
int PilaLlena(TipoPila *Stack);
int PilaVacia(TipoPila *Stack);
void Push (TipoPila *Stack,TipoElem Elemen);
int Pop (TipoPila *Stack,TipoElem *Elemen);
int Imprimir (TipoPila Stack);
int Contar (TipoPila Stack);
 main ()
{
system ("color a9");
TipoPila Pila;
TipoTope Tope=0;
TipoElem Elementos=0;
int opcion1=0;
while (opcion1!='s')
{
cout << "\n\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila: \n";
  cout <<"2 Ingresar elementos a la pila: \n";
  cout <<"3 Sacar elementos de la pila: \n";
   cout <<"4 Imprimir elementos de la pila: \n";
   cout <<"5 Contar elementos de la pila: \n";
   cout <<"\n opcion:";
 cin >> opcion1;
 system ("cls");
 switch (opcion1)
{
       case 1:
       InicializarPila(&Pila);
       cout<<"Pila inicializada ...\n";
       getch ();
       system ("cls");
       break;
       
       case 2:
       if(PilaLlena(&Pila)){
       cout << "\nPila llena!!!!\n";}
       else{
       cout<<"Ingrese elementos a la pila:";
       cin >> Elementos;
       Push(&Pila,Elementos);
       getch ();
       system ("cls");
       break;
       
       case 3:
       if(PilaVacia(&Pila)){
       cout << "\nLa pila esta vacia ingrese elementos primero!!!!\n";
       }
       else
       {
       Pop(&Pila,&Elementos);
       cout <<"\n El elemento sacado de la pila es: "<<Elementos;
       }
       getch ();
       system ("cls");
       break;
       
       case 4:
       cout << Imprimir(Pila);
       getch ();
       system ("cls");
       break;  
       
       case 5:
       cout <<  Contar(Pila);
       getch ();
       system ("cls");
       break;       
}}}
getch ();
}
//InicializarPila
void InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
//PilaLlena
int PilaLlena(TipoPila *Stack)
{
    return (Stack->Tope==MAX);
}
//PilaVacia
int PilaVacia(TipoPila *Stack)
{
 return (Stack->Tope==VACIO);
}
//Push
void Push (TipoPila *Stack,TipoElem Elemen)
{
 Stack->Tope++;
 Stack->Elementos[Stack->Tope]=Elemen;
  
 }
 //Pop
int Pop (TipoPila *Stack,TipoElem *Elemen)
{   
  
  *Elemen=Stack->Elementos[Stack->Tope];
  Stack->Tope--;
  return *Elemen;
 }
 //Imprimir
 int Imprimir (TipoPila Stack)
 {
TipoElem Elemen;
while (!PilaVacia(&Stack))
{
       Pop (&Stack,&Elemen);
       cout <<"\n"<<Elemen;
}         
      }
//Contar
int Contar (TipoPila Stack)
{
 int contador=0;
 TipoPila Aux;
 TipoElem Elemen;  
 InicializarPila (&Aux);
 while (!PilaVacia(&Stack))
 {
 Pop(&Stack,&Elemen);
 contador++;
 cout << contador;
 Push(&Aux,Elemen);
 }
}
 

[CalgaryCorpus]

- La funcion Imprimir() la has definido que devuelve int.
- No pusiste ningun return al interior de su definicion
- Luego la llamaste e imprimiste el valor de retorno

Recomendaciones:
- Si no estas interesado en el valor que una funcion retorna, definela con void.
- Al invocarla, no uses cout, pues una funcion void no tiene retorno. De hecho, tal como esta, no tiene sentido usar cout para invocarla, aunque la idea sea imprimir los valores, eso es lo que ya hace la funcion. Solo llamala, no la imprimas.

[vnvnation]

Entonces seria a si verdad o aun esta ma???

Código C++:

#include <iostream.h>
#include <conio.h>
#define MAX 3
#define VACIO -1
typedef int TipoTope;
typedef char TipoElem;
typedef struct TipoPila{
         TipoTope Tope ;
          TipoElem Elementos [MAX];
          }Pila;
void InicializarPila (TipoPila *Stack);
int PilaLlena(TipoPila Stack);
int PilaVacia(TipoPila Stack);
void Push (TipoPila *Stack,TipoElem Elemen);
int Pop (TipoPila *Stack,TipoElem *Elemen);
void Imprimir (TipoPila Stack);
void Contar (TipoPila Stack);
 main ()
{
system ("color a9");
TipoPila Pila;
TipoTope Tope=0;
TipoElem Elementos=0;
int opcion1=0;
while (opcion1!='s')
{
cout << "\n\nSELECCIONE UNA OPCION DE LAS SIGUIENTES:";
 cout <<"\n1 Inicializar Pila: \n";
  cout <<"2 Ingresar elementos a la pila: \n";
  cout <<"3 Sacar elementos de la pila: \n";
   cout <<"4 Imprimir elementos de la pila: \n";
   cout <<"5 Contar elementos de la pila: \n";
   cout <<"\n opcion:";
 cin >> opcion1;
 system ("cls");
 switch (opcion1)
{
       case 1:
       InicializarPila(&Pila);
       cout<<"Pila inicializada ...\n";
       getch ();
       system ("cls");
       break;
       
       case 2:
       if(PilaLlena(Pila)){
       cout << "\nPila llena!!!!\n";}
       else{
       cout<<"Ingrese elementos a la pila:";
       cin >> Elementos;
       Push(&Pila,Elementos);
       getch ();
       system ("cls");
       break;
       
       case 3:
       if(PilaVacia(Pila)){
       cout << "\nLa pila esta vacia ingrese elementos primero!!!!\n";
       }
       else
       {
       Pop(&Pila,&Elementos);
       cout <<"\n El elemento sacado de la pila es: "<<Elementos;
       }
       getch ();
       system ("cls");
       break;
       
       case 4:
        Imprimir(Pila);
       getch ();
       system ("cls");
       break;  
       
       case 5:
        Contar(Pila);
       getch ();
       system ("cls");
       break;       
}}}
getch ();
}
//InicializarPila
void InicializarPila(TipoPila *Stack) 
{
     Stack->Tope=VACIO;
     }
//PilaLlena
int PilaLlena(TipoPila Stack)
{
    return (Stack.Tope==MAX);
}
//PilaVacia
int PilaVacia(TipoPila Stack)
{
 return (Stack.Tope==VACIO);
}
//Push
void Push (TipoPila *Stack,TipoElem Elemen)
{
 Stack->Tope++;
 Stack->Elementos[Stack->Tope]=Elemen;
  
 }
 //Pop
int Pop (TipoPila *Stack,TipoElem *Elemen)
{   
  
  *Elemen=Stack->Elementos[Stack->Tope];
  Stack->Tope--;
  //  return *Elemen;
 }
 //Imprimir
 void Imprimir (TipoPila Stack)
 {
TipoElem Elemen;
while (!PilaVacia(Stack))
{
       Pop (&Stack,&Elemen);
       cout <<"\n"<<Elemen;
}         
      }
//Contar
void Contar (TipoPila Stack)
{
 int contador=0;
 TipoPila Aux;
 TipoElem Elemen;  
 InicializarPila (&Aux);
 while (!PilaVacia(Stack))
 {
 Pop(&Stack,&Elemen);
 contador++;
 cout << contador;
 Push(&Aux,Elemen);
 }
}
 

[CalgaryCorpus]

Supongo que el 1 extraño, que antes relatabas, dejó de salir. Tu deberias saberlo.

[vnvnation]

Si mi amigo desaparecio si efectivamente tienes mucha razon se te agradace, fui a revision y me dijeron que en la opcion 5 la de contar cuando no tengo elementos deve de aparecer 0 pero no me aparece, ahora tengo que hacer una funcion que me cuentes cuantas vocales hay en mi mila, cren que seriaa bueno usar un if o una funcion ¿? que me recomiendan?

MUCHAS GRACIAS
sam90
CalgaryCorpus

[sam90]

Haces los mismo que contar, pero el contador aumenta si el elemento es una vocal.

if (Elemen == 'a' || Elemen == 'e' ......) contador++;

[vnvnation]

Hola bueno el de las vocales ya quedo y quedo a si

Código C++:

void Vocales(TipoPila Stack)
{
int contador=0;
 TipoPila Aux;
 TipoElem Elemen;  
 InicializarPila (&Aux);
 while (!PilaVacia(Stack))
 { 
 Pop(&Stack,&Elemen);
 if ( (Elemen =='a') || (Elemen =='e') || ( Elemen =='i'  ) || ( Elemen =='o'  ) || ( Elemen =='u'))
 {
 contador++;
 Push(&Aux,Elemen);
 cout <<"\n"<<contador;
 } 
 }
 }
 

Pero ahora necesito que imprima mis elementos en el orden que los meti y otra que remplaze todos los elementos x po elementos y. Estas son mis funciones en la de imprimir ordenadamente aun no tengo una idea clara

Código C++:

//Imprimir 0rdenadamente
 
 void ImprimirOrden (TipoPila Stack)
 {
TipoElem Elemen;
TipoPila Aux1;
InicializarPila (&Aux1);
while (!PilaVacia(Stack))
{
       Pop (&Stack,&Elemen);
       Push(&Aux1,Elemen);
       
}         
      }
//Remplazar
void Remplazar (TipoPila *Stack,TipoElem x,TipoElem y)
{
TipoPila Aux;
TipoElem Elemen;
InicializarPila (&Aux);
while (!PilaVacia(*Stack))
{
       Pop (&(*Stack),&Elemen);
if(Elemen=x)
{Push(&Aux,y);}
else{
Push(&Aux,Elemen);}
}
while (!PilaVacia(Aux)){
Pop (&Aux,&Elemen);
Push(&(*Stack),Elemen);}
}
 

[sam90]

EL de imprimir te faltaria llamara a la funcion imprimir que hiciste anteriormente pero con la lista Aux1 como argumento. Ya que diste vuelta el orden popeando y pusheando los elementos de una pila a la otra.

[vnvnation]

Aver si ententi lo hice a si y al correrlo si me imprime como los ingrese pero el 1er elemento de mi pila me aparece al principio y al final

Código C++:

void ImprimirOrden (TipoPila Stack)
 {
TipoElem Elemen;
TipoPila Aux1;
InicializarPila (&Aux1);
while (!PilaVacia(Stack))
{                        
       Pop (&Stack,&Elemen);
       Imprimir (Stack);
       Push(&Aux1,Elemen);
       cout <<"\n"<<Elemen;
}         
      }
 

[sam90]

A esto me referia. Tienes que empezar a usar la logica....sino no vas avanzar nada por tu cuenta.

Código C++:

void ImprimirOrden (TipoPila Stack)
 {
TipoElem Elemen;
TipoPila Aux1;
InicializarPila (&Aux1);
while (!PilaVacia(Stack))
{                        
       Pop (&Stack,&Elemen);
       Push(&Aux1,Elemen);
 }
Imprimir (Aux1);         
}