Hola, estoy haciendo un proyecto de pasar de notacion infija a postfija, estoy usando el dev c++ pero no he podido terminar el programa por que me esta dando estos errores en varias funciones:
'Pila' was not declared in this scope expected ',' or ';' before '{' token
'Pil' undeclared (first use this function)
'CrearPila' cannot be used as a function

Este es mi archivo .h:

#include <iostream>
#include <conio.h>
#include <string.h>
#include <stdio.h>
using namespace std;

typedef char TipoDato;


int PilaLlena(Pila P)
{
    return(P.cima == TAM -1)?1:0;
}
int PilaVacia(Pila P)
{
    return (P.cima == -1)?1:0;
}
void Ingresar(Pila *P, TipoDato x)
{
     if(PilaLlena(*P))
     {
                      puts("Error, Pila llena");
                      return;
                      //exit(-1);
     }
     P->lista[++P->cima] = x;
}

TipoDato Quitar(Pila *P)
{
     if(PilaVacia(*P))
     {
                      puts("Error, pila vacia");
                      TipoDato xx;
                      return xx;
                      //exit(-1);
     }
     TipoDato aux = P->lista[P->cima];
     P->cima--;
     return aux;
}
TipoDato Cima(Pila P)
{
         if(PilaVacia(P))
         {
                         puts("Error");
                         TipoDato xx;
                         return xx;
                         //exit(-1);
         }
         return (P.lista[P.cima]);
}
void CrearPila(Pila *P)
{
     P->cima = -1;
}


ESTE ES MI ARCHIVO .CPP:

#include <iostream>
#include <conio.h>
#include <string.h>
#include <stdio.h>
#include "proyecto2.h"
#define MAX 20

using namespace std;

int Proced(TipoDato cima,TipoDato simb);
int main ()
{
    TipoDato simb,Cad[MAX]={' '};
    Pila Pil;
    int a=0,i,flag=0;
    CrearPila(&Pil);
    puts("introduce una operacion en notacion interfija");
    while((simb=getchar())!='n'){
          if(simb!=('/') && simb!=('*') && simb!=('-') && simb!=('+') && simb!=('^') && simb!=('(') &&simb!=(')')){
             Cad[a]=simb;
             a=a+1;
             }
             else{
                if(simb=='('){
                  Cad[a]=simb;
                  a=a+1;
                  flag=1;}
                   else if(simb==')'){
                       while(!PilaVacia(Pil)){
                        Cad[a]=Quitar(&Pil);
                        a=a+1;
                        }
                        Cad[a]=simb;
                        a=a+1;
                        flag=0;
                        }
                     else if(!PilaVacia(Pil) && Proced(Cima(Pil),simb)){
                        while(!PilaVacia(Pil) && Proced(Cima(Pil),simb)){
                            Cad[a]=Quitar(&Pil);
                            a=a+1;                   
                     }}
                  if(simb!=')' && simb!='(')
                  Ingresar(&Pil,simb);
                  }
             }

    while(!PilaVacia(Pil)){
    Cad[a]=Quitar(&Pil);
    a=a+1;
}
puts(Cad);
system("pause");
}

int Proced(TipoDato cima,TipoDato simb)
{
if(cima=='^')
   {
    return 1; 
             }
    else if((cima=='*' || cima=='/') && (simb=='-' || simb=='+'))
           {
           return 1;
                       }
         else{
              return 0;}
}

Les agradezco cualquier contribucion, ya que no tengo idea donde estan los errores del codigo.
gracias

hola!
necesito ayuda para hacer un programa en c++ para simular un sorteo donde se dispone de:
 una lista de n nombres que participan en el sorteo.
 una cola de m premios (m<=n)
 una lista de premiados (pareja de premio-premiado)

estoy intentando el primer punto pero no se como agregar nombres en una lista, ya que solo he visto lista con enteros y no caracteres, aparte debo modificar el codigo visto en clase para poder realizarlo.

Agradezco la guia o ayuda q me puedan dar en este foro.

#include <iostream>
using namespace std;
 
class nodo {// guarda la informacion que vamos a manejar en la lista, valor de informacion int entero
   public:
    nodo(int v, nodo *sig = NULL)//constructor que tiene dos parametros, puede se un valor y no null tambien
    {
       valor = v;
       siguiente = sig;
    }
 
   private:
    int valor;//nodo de tipo entero
    nodo *siguiente;//puede apuntar a cualquier instancia de la clase nodo,puntero hacia una instancia
 
   friend class lista;//nodo le da permiso a lista para trabajar con la class private                                                                 
};
 
typedef nodo *pnodo;//tipo de dato llamado pnodo(nombre del dato) que apunta hacia una instancia de tipo nodo y * es el puntero
 
class lista {//tiene varios metodos, permite crear nodos y manejarlos
   public:
    lista() { primero = actual = NULL; }//cuando se crea la lista primero y actual quedan null
    ~lista();// destructor de la clase ~(alt 126), se llama igual que la clase, no retorna a nada ni recibe parametros y sirve para limpiar la lista, vaciar el espacio en memoria
 
    void Insertar(int v);//inserta un valor en la lista y debe ser entero
    void Borrar(int v);//se debe indicar el elemento a borrar, entoces se llama al elemento a borrar
    bool ListaVacia() { return primero == NULL; }//si la lista da null es porque esta vacia 
    void Mostrar();//lo que hace es recorrer la lista y la muestra
    void Siguiente();//pasa al siguiente elemento
    void Primero();
    void Ultimo();
    bool Actual() { return actual != NULL; }
    int ValorActual() { return actual->valor; }
 
   private:
    pnodo primero;// es un puntero a alguna instacia de nodo
    pnodo actual;//es un puntero hacia un nodo
};
 
lista::~lista()
{
   pnodo aux;
 
   while(primero) {
      aux = primero;
      primero = primero->siguiente;
      delete aux;//
   }
   actual = NULL;
}
 
void lista::Insertar(int v)
{
   pnodo anterior;
 
   // Si la lista est&#225; vac&#237;a
   if(ListaVacia() || primero->valor > v) {
      // Asignamos a lista un nuevo nodo de valor v y
      // cuyo siguiente elemento es la lista actual  
 
      primero = new nodo(v, primero);//se crea un nuevo nodo
   }
   else {
      // Buscar el nodo de valor menor a v 
      anterior = primero;//anterior apunte hacia donde esta apuntando primero (el puntero lo que va va hacer es guardar una direccion de memoria)
      // Avanzamos hasta el &#250;ltimo elemento o hasta que el siguiente tenga 
      // un valor mayor que v 
 
      while(anterior->siguiente && anterior->siguiente->valor <= v) 
         anterior = anterior->siguiente;
      // Creamos un nuevo nodo despu&#233;s del nodo anterior, y cuyo siguiente
      // es el siguiente del anterior
      anterior->siguiente = new nodo(v, anterior->siguiente);//anterior siguiente va a apuntar hacia un nuevo nodo osea la ubicacion de memoria donde lo vamos a crear
   }  //anterior siguiente vale null
}
 
void lista::Borrar(int v)
{
   pnodo anterior, nodo;
 
   nodo = primero;
   anterior = NULL;
   while(nodo && nodo->valor < v) {
      anterior = nodo; 
      nodo = nodo->siguiente;
   }
   if(!nodo || nodo->valor != v) return;
   else { // Borrar el nodo 
      if(!anterior) // Primer elemento 
         primero = nodo->siguiente;
      else  // un elemento cualquiera
         anterior->siguiente = nodo->siguiente;
      delete nodo;
   }   
}
 
void lista::Mostrar()
{
   nodo *aux;
 
   aux = primero;
   while(aux) {
      cout << aux->valor << "-> ";
      aux = aux->siguiente;
   }
   cout << endl;
}
 
void lista::Siguiente()
{
   if(actual) actual = actual->siguiente;
}
 
void lista::Primero()
{
   actual = primero;
}
 
void lista::Ultimo()
{
   actual = primero;  
   if(!ListaVacia()) 
      while(actual->siguiente) Siguiente();
}