Dev - C++ - pilas en c++

alguien le puede conseguir el porque no me sirve el siguiente codigo. lo compila sin errores ni warnings, pero al seleccionar apilar, retirar u ordenar, se tranca la corrida.
#include <stdio.h>
#include <conio.h>
struct t_pila{
int tope;
int valores[10];
};
int menu();
void inicializar(t_pila mi_pila);
void apilar(t_pila mi_pila,int a);
void retirar(t_pila mi_pila,int r);
void ordenar(t_pila mi_pila);
int pila_vacia(t_pila mi_pila);
int pila_llena(t_pila mi_pila);
int existe(t_pila mi_pila,int search);
int cuantoshay(t_pila mi_pila);

int main(void)
{int k=0;
int m,b,re;
t_pila datos;
while(k==0)
{m=menu();
if (m==1)
{inicializar(datos);}
if (m==2)
{printf("No. a guardar ");
scanf("%d",&b);
apilar(datos,b);
}
if (m==3)
{retirar(datos,re);
}
if (m==4)
{ordenar(datos);}
if (m==0)
{k =1;}
}
return(0);
}
int menu()
{int c;
printf("1. Inicializar\n");
printf("2. Apilar\n");
printf("3. Retirar\n");
printf("4. Ordenar\n");
printf("0. Salir\n");
scanf("%d",&c);
return(c);
}

void inicializar(t_pila mi_pila)
{mi_pila.tope = -1;
}
void apilar(t_pila mi_pila, int a)
{mi_pila.tope++;
mi_pila.valores[mi_pila.tope]=a;
}
void retirar(t_pila mi_pila, int r)
{r = mi_pila.valores[mi_pila.tope];
mi_pila.tope = mi_pila.tope-1;
}
void ordenar(t_pila mi_pila)
{struct t_pila temp;
struct t_pila orden;
int m,a;
inicializar(temp);
inicializar(orden);
while (pila_vacia(mi_pila)==0)
{retirar(mi_pila,m);
while(pila_vacia(mi_pila)==0)
{retirar(mi_pila,a);
if (a>m)
{apilar(temp,m);
m=a;}
else
{apilar(temp,a);
}
}
apilar(orden,m);
while(pila_vacia(temp)==0)
{retirar(temp,a);
apilar(mi_pila,a);
}
}
while(pila_vacia(orden)==0)
{retirar(orden,a);
apilar(mi_pila,a);
}
}
int pila_vacia(t_pila mi_pila)
{if (mi_pila.tope == -1)
{return(1);}
else
{return(0);}
}
int pila_llena(t_pila mi_pila)
{if (mi_pila.tope == 9)
{return(1);}
else
{return(0);}
}
int existe(t_pila mi_pila,int search)
{int i =0;
int k = 0;
while((i<=mi_pila.tope)&&(k==0))
{if (mi_pila.valores[i]==search)
{k=1;
}
i++;
}
return(k);
}
int cuantoshay(t_pila mi_pila)
{return(mi_pila.tope+1);
}

sale el menu, selecciono 1 y todo bien, vuelve a mostrar menu, le doy 2 para apilar, me pregunta el No a guardar, le introduzco un numero cualquiera, y se tranca al darle enter.
seleccionando 3 del menu, se tranca, e igual con 4 (que son retirar y ordenar respectivamente).

Tienes problemas con C++?
escribeme que con gusto te ayudaré

Luis Aljure

Podrias ayudarme a mi? soy estudiante de ingenieria en sistemas en linea, sin embargo estoy batallando para realizar los programas que me piden puesno tengo un maestro presencial, ojala pudieras ayudarme te lo agradecere enormemente.

Hola buenas tardes lo que pasa es que no le entiendo bien a pilas y me encargaron en la escuela hacer un programa que lea un palindromo usando pilas me podrian orientar por favor

Hola, me gustaría saber porque s eme hace un ciclo infinito en este ejercicio de pilas, le he buscado solución, pero lo más cerca que he estado es mostrar los datos pero, se muestra un numero raro al final, me imagino que es porque algún apuntador esta por hay disparado, pero bueno quisiera una ayuda, tengo que ordenar los valores de la pila, pero antes quisiera saber como arreglar ese problema con ciclo infinito, este es el codigo..

programa de PILAS utilizando UNICAMENTE CICLOS FOR

Hola Guar0x,

Veo varios errores en tu código el primero es que las estructuras por parametro por valor se deben pasar de la siguiente manera (pasamos una copia de la pila ya que el contenido de la pila no se ve alterado):

int pila_llena(struct t_pila mi_pila);
int existe(struct t_pila mi_pila,int search);
int cuantoshay(struct t_pila mi_pila);

las llamadas serán pila_llena(datos),etc.

En los métodos apilar,retirar,etc en los que la pila se modifica luego deberás pasar la estructura mi_pila por referencia sino cuando después de llamar a la función apilar(por ejemplo) vuelvas al main() el valor apilado no se habra guardado (se pasa al metodo la dirección de memoria donde esta "datos").
Estos metodos deben ser asi:

void inicializar(struct t_pila* mi_pila);
void apilar(struct t_pila* mi_pila,int a);
void retirar(struct t_pila* mi_pila,int r);
void ordenar(struct t_pila* mi_pila);

las llamadas serán inicializar(&datos),apilar(&datos,a), etc. se usa & ya que pasamos la dirección de memoria donde esta almacenada la pila.

Otra cosa que me llama la atención es el método retirar, en las pilas se retira el último elemento apilado (el ultimo elemento de datos.valores[]), debería ser asi
void retirar(struct t_pila* mi_pila).

respecto a la comprobación pila_vacia() y pila_llena() yo lo haria dentro de los metodos retirar() y apilar() para ahorrar llamadas y que el programa sea algo más eficiente.

Un saludo.