• Usar contenedores de la STL como <set>, <multiset> u otros.
• Usar un array unidimensional de TAM = numCartas y cada vez que escoges una carta, la pones en array[numCartasDisponibles - 1] y decrementas <numCartasDisponibles>.

• Nombre de variables mejorables. No hay nada como leer un código y no tener que volver al principio para recordar qué hacía una variable llamada <a> por ejemplo.
• Asignas dos veces 0 a <sum> de forma innecesaria.
• Asignas dos veces 0 a <cont> de forma innecesaria.
• Las asignaciones que hay dentro de los <printf()> no son nada claras de ver.
• No usar "magic numbers".
• Primero trabaja con los datos (lee valores, guarda valores, realiza cálculos, etc) y al final muestra los resultados. Así queda más claro el código.

struct Persona{
    string nombre;
    int edad;
};
 
int main(){
    Persona persona1;
    Persona *punteroPersona = &persona1;
 
    cout << "Nombre persona: ";
    getline(cin, punteroPersona->nombre); // equivale a: getline(cin, (*punteroPersona).nombre)
    //...
} 

• Acceder al dato del puntero: <*punteroPersona>
• Acceder al dato miembro de ese datos: <(*punteroPersona).nombre>

• La función <menu()> sigue haciendo demasiadas cosas y algunas mal... Y sigue recibiendo un parámetro inútil... Además de que le sobran variables...
• La función <crearPilaVacia()> sigue retornando un <bool> y en tu caso no retorna nada...
• Las funciones <pilaLlena()> y <pilaVacia()> las puedes acortar a una sola línea como te comenté...
• A la función <apilar()> le falta el <return> y aunque la función está mejor, cuando la llamas en el <case> vuelves a hacerla inútil...
• Las funciones <cima()> está bien.
• La función <visualizarElementos()> debe retornar un <float> y no lo hace...
• La función <sumaPila()> tiene dos variables para hacer lo que se puede hacer con una...

• Mandar <eleccion> como parámetro en <menu()> (línea 24)
• Crear la variable <acum> en <menu()> (línea 28)
• Llamar a la función <crearPilaVacia()> en el <printf()> (línea 47)
• LLamar a las funciones <pilaVacia()> y <pilaLlena()> (líneas 51 y 56)
• El bloque del <case 4> (líneas 62 - 64)
• La llamada a la función <sumaPila()> (línea 77)
• Los valores de retorno <return> que le has asignado a cada función

T top(); // devuelve el ultimo elemento de la pila del tipo que sea (int/float/char/...)
void push(T elemento); // introduce un nuevo elemento
void pop(); // saca el ultimo elemento de la pila
bool empty(); // devuelve true/false dependiendo de si la pila esta vacia o no
int size(); // devuelve el numero de elementos que contiene la pila 

T front(); // devuelve el elemento que antes se inserto en la cola
void pop(); // elimina el elemento que antes se inserto
T back(); // devuelve el elemento que se inserto el ultimo
// No existe un pop() para eliminar el ultimo ya que entonces no seria una cola ya que dejaria de ser FIFO
void push(T elemento); // introduce un nuevo elemento a la cola
bool empty(); // devuelve true/false dependiendo de si la cola esta vacia o no
int size(); // devuelve el numero de elementos que contiene la cola 

void push_back(T elemento); // inserta un elemento al final de la lista
void push_front(T elemento); // inserta un elemento al comienzo de la lista
void pop_back(); // elimina el ultimo elemento de la lista
void pop_front(); // elimina el primer elemento de la lista
T front(); // devuelve el primer elemento de la lista
T back(); // devuelve el ultimo elemento de la lista
bool empty(); // devuelve true/false dependiendo de si la lista esta vacia o no
int size(); // devuelve el numero de elementos de la lista 

• Evitar el uso de variables globales siempre que se pueda
• Evitar mostrar mensajes dentro de las funciones a no ser que la función se encargue justo de eso, de mostrar un mensaje (ej; un menú).
• Las constantes en mayúsculas. Por ejemplo <max> -> <MAX>

int main(){
    int eleccion;
    menu(eleccion);
}
 
int main(){
    int eleccion = mostrarMenu();
    while(eleccion != -1){
        switch(eleccion){
            case 1:
                pilaNueva();
                break;
            case 2:
                if(pilaVacia()) printf("La pila esta vacia");
                else printf("La pila no esta vacia");
                break;
            // y asi con todos que me canso de seguir...
        }
        eleccion = mostrarMenu(); // al acabar lo que sea volvemos a dar a elegir
    }
} 

• 1. No tiene ningún valor definido,
• 2. No sirve para nada fuera de la función.

• Objetivo de la función: insertar un elemento en la pila.
• Parámetro: el elemento a insertar.

bool pilaVacia(){
    if(tope == -1){ // comprueba si lo de dentro del parentesis es true o false...
        return true; // ... si el parentesis vale true, devuelve true
    }
    else{ //... si el parentesis vale false...
        return false; // ... devuelve false
    }
}
// Al final lo que haces es devolver lo mismo que el resultado del parentesis
// No sera mejor entonces devolver directamente el resultado del parentesis?
bool pilaVacia(){
    return (tope == -1);
} 

printf("Los elementos de la pila son: ");
visualizarElementos(); 

printf("La suma de los elementos de la pila es: %d", sumaPila()); 

// Cuando se repite la misma variable justo antes y justo despues del = se puede acortar:
suma += otro; // equivale a: suma = suma + otro
resta -= otro; // equivale a: resta = resta - otro
producto *= 2; // equivale a: producto = producto * 2
// etc...
// Para incrementar variables en una unidad se puede hacer:
++numero; // equivale a: numero = numero + 1
numero++; // equivale a: numero = numero + 1
// Para decrementar variables en una unidad se puede hacer:
--numero; // equivale a: numero = numero - 1
numero--; // equivale a: numero = numero - 1 

// Poner:
if(condicion == true){...}
// ...es lo mismo que poner:
if(condicion){...}
// Al igual que para:
if(condicion == false){...}
// ...es lo mismo que poner:
if(!condicion){...} 

void ordenarAscendente(int *numeros, int size){
    for(size_t i = 1; i < size; ++i)
        for(size_t j = 0; j < size-i; ++j)
            if(numeros[j] > numeros[j+1]){
                numeros[j] += numeros[j+1];
                numeros[j+1] = numeros[j] - numeros[j+1];
                numeros[j] -= numeros[j+1];
            }
}
 
void ordenarDescendente(int *numeros, int size){
    for(size_t i = 1; i < size; ++i)
        for(size_t j = 0; j < size-i; ++j)
            if(numeros[j] < numeros[j+1]){
                numeros[j] += numeros[j+1];
                numeros[j+1] = numeros[j] - numeros[j+1];
                numeros[j] -= numeros[j+1];
            }
} 

bool mayor(int a, int b){
    return a > b;
}
 
bool menor(int a, int b){
    return a < b;
}
 
void ordenar(int *numeros, int size, bool (*orden)(int,int)){
    for(size_t i = 1; i < size; ++i)
        for(size_t j = 0; j < size-i; ++j)
            if(!orden(numeros[j], numeros[j+1])){
                numeros[j] += numeros[j+1];
                numeros[j+1] = numeros[j] - numeros[j+1];
                numeros[j] -= numeros[j+1];
            }
} 

void incrementar(void *puntero, int size){
    if(size == sizeof(char)){
        char *p_char = (char*)puntero;
        ++(*p_char);
    }
    if(size == sizeof(int)){
        char *p_int = (int*)puntero;
        ++(*p_int);
    }
}
 
int main(){
    char letra = 'a';
    int numero = 1;
    incrementar(&letra, sizeof(letra));
    incrementar(&numero, sizeof(numero));
    cout << letra << " - " << numero << endl;
} 

Salida: b - 2 

int sumar(int a, int b){
    return a + b;
}
 
int restar(int a, int b){
    return a - b;
}
 
int realizarOperacion(int (*operacion)(int,int), int a, int b){
    int resultado = (*operacion)(a,b);
    return resultado;
}
 
int main(){
    int a = 4, b = 1;
    int (*realizarResta)(int,int) = restar;
    int resultadoSuma = realizarOperacion(sumar, a, b);
    int resultadoResta = realizarOperacion(realizarResta, resultadoSuma, b);
} 

void funcion(int**& p_m) // usando new 
//seria equivalente a:
void funcion(int m[][100] 

void funcion1(int **matriz); // pasamos la direccion de memoria del elemento [0][0]
void funcion2(int **&matriz); // pasamos la direccion de memoria que apunta a la direccion de memoria del elemento [0][0]
void funcion3(int matriz[][TAM]); // igual que funcion1() pero necesitamos indicar todas las dimensiones excepto la primera
void funcion4(int &matriz[][TAM]); // igual que funcion2() pero indicando las dimensiones como en la funcion3() 

int miArray[5]; 

int *miArray = new int[5]; 

int *miArray = new int[10];
int *otroArray = new int[5];
// Queremos intercambiarlos pero en cuanto asignemos algo a uno de esos punteros, perderemos el array entonces:
int *auxiliar = miArray; // Ahora el primer array tiene dos nombres: <auxiliar> y <miArray>
miArray = otroArray; // Ahora hacemos que el puntero <miArray> apunte al mismo sitio que <otroArray>
otroArray = auxiliar; // Y ahora <otroArray> apunta al mismo sitio que <auxiliar> que era el array original al que apuntaba <miArray> 

delete [] auxiliar;