Aquí tenéis otra solución:

int contarVocales(const string &frase){
    int contador = 0;
    for(size_t i = 0; i < frase.size(); i++){
        switch(tolower(frase[i])){
            case 'a': case 'e': case 'i': case 'o': case 'u':
                contador++;
        }
    return contador;
} 

O sin usar el switch:

int contarVocales(const string &frase){
    int contador = 0;
    char actual;
    for(size_t i = 0; i < frase.size(); i++){
        actual = tolower(frase[i]);
        if(actual == 'a' || actual == 'e' || actual == 'i' || actual == 'o' || actual == 'u')
            contador++;
    }
    return contador;
} 

Pero en ese código no estás usando ninguna lista, imagino que quieres ir metiendo en una lista las variables <re> e <im> (te recomiendo nombres un poco más largos y que se entiendan mejor <real> e <imaginaria> porque variables con nombres muy cortos podrían significar más cosas, mejor el nombre completo si no es muy largo).

Para lo que quieres hacer te recomiendo empezar a usar objetos, es decir, crear una <struct> o <class> para almacenar un valor. Sería algo así:

struct Rectangular{
    double real;
    double imaginaria;
};
 
int main(){
    Rectangular variable_rectangular;
    cout << "Ingresa parte real: ";
    cin >> variable_rectangular.real;
    cout << "Ingresa parte imaginaria: ";
    cin >> variable_rectangular.imaginaria;
    // y aqui ya puedes meter la variable_rectangular en una lista
} 

Te recomiendo mejor que crees dos clases, una Rectangular y otra Polar, hagas un constructor con parámetros, y métodos que te sirvan de algo por ejemplo:

class Rectangular{
    private:
        double real;
        double imaginaria;
 
    public:
        Rectangular(); // constructor por defecto
        Rectangular(double real, double imaginaria); // constructor con parametros
        Polar convertir(); // convierte una variable Rectangular en Polar
        //...
};
 
class Polar{
    private:
        double modulo;
        double angulo;
 
    public:
        Polar();
        Polar(double modulo, double angulo);
        Rectangular convertir(); // convierte una variable Polar a Rectangular
        //...
}; 

Puedes agregarle más métodos si los necesitas y para meterlos en una lista sólo tienes que crear una lista de variables <Rectangular> para meter esos valores y una lista de tipo <Polar> para meter esos valores. Suerte

<valor> es el número que vayas a guardar, en tu caso un número aleatorio. He puesto <valor> para no escribirlo todo.

La suma de columnas está mal porque si te fijas tienes una matriz de 12 columnas y tú estás intentando guardar la suma en la columna 15...

for(x=0;x<15;x++){
    acu=0;
    for(y=0;y<11;y++)
        acu=acu+arr[x][y];
    arr[y][15]=acu; // Esto siempre vale arr[11][15]
} 

Tienes que pensar bien la relación de los índices. Por ejemplo la suma de filas lo que hace es sumar la fila x y lo guarda en la posición matriz

• [11]. Pero la suma de columnas, suma la columna x y lo estás guardando en la posición matriz[11][15]. Entonces tienes dos problemas, primero que siempre sobrescribes la misma posición y segundo que esa posición está fuera de la matriz.

PD: Si quieres sumar una columna y guardar la suma en la última posición de esa columna tienes que dejar la última fila sin valores al igual que la última columna.

const int FILAS = 16, COLUMNAS = 12;
int i, j;
int matriz[FILAS][COLUMNAS];
 
for(i = 0; i < FILAS-1; i++) // no escribimos en la ultima fila
    for(j = 0; j < COLUMNAS-1; j++) // no escribimos en la ultima columna
        matriz[i][j] = valor;
 
// suma de filas
for(i = 0; i < FILAS-1; i++){ // este for recorre las filas desde la 0 hasta la 14 incluida
    suma = 0;
    for(j = 0; j < COLUMNAS-1; j++) // este for recorre las columnas desde la 0 hasta la 10 incluida
        suma += matriz[i][j];
    matriz[i][j] = suma; // guardamos en la posicion [x][11] la suma de la fila x
 
// tambien se puede hacer sin usar una variable suma
for(i = 0; i < FILAS-1; i++){
    matriz[i][COLUMNAS-1] = 0; // ponemos la ultima posicion de la fila a 0...
    for(j = 0; j < COLUMNAS-1; j++)
        matriz[i][COLUMNAS-1] += matriz[i][j]; // ... y vamos acumulando cada posicion de esa fila
 

La parte de sumar las columnas te la dejo a ti para que practiques. Suerte
Pista: Tienes que darle la vuelta a los <for> y guardar en la posición [15]

• la suma de la columna x...

Muestra cómo estás haciendo la suma por columnas para poder ver el error...

Lo primero de todo coloca tu código entre etiquetas GeSHi, ya que como puedes comprobar tú mismo ese código es ilegible. Y también hay alguna instrucción en dos líneas, corrige eso para que se pueda entender mejor.

Para sumar cada columna tienes que pensar la relación que tiene una columna (la segunda coordenada es siempre la misma). Entonces dos bucles anidados, el exterior se mueve por las columnas y el interior por las filas, y una vez que acaba el bucle interior y se ha ido sumando cada valor, se almacena al final de esa columna. Suerte

PD: No uses la librería <conio.h> ya que no es estándar. Sólo la necesitas para usar <getch()>. Puedes sustituir <getch()> por <getchar()> y así ya no necesitas incluir esa librería.

Cuando operas dos variables de tipo <int>, el resultado resulta de tipo <int> aunque lo guardes en un <double/float>. Por ejemplo:

int a = 5, b = 2;
double res = a / b;
cout << res; 

Este trozo de código te mostraría por pantalla "2". Esto es porque divides (int)5 / (int)2 entonces el resultado es (int)2. Entonces aunque luego lo guardes en un <double> es como hacer <double res = 2>.

Para evitar esto se puede cambiar el tipo al menos a uno de los operandos, una operación entre dos variables numéricas distintas devuelve el resultado con el tipo más grande de los dos operandos:
- <int> / <int> = <int>
- <double> / <int> = <double> (y al revés igual)

Para no modificar el tipo puedes hacer un casting justo antes de la operación, quedaría algo así:

int a = 5, b = 2;
double res = (double)a / b; // o a / (double)b el resultado es el mismo 

Así conviertes la variable <a> en <double> pero sólo para hacer esa operación, después de hacer la división seguirá siendo de tipo <int>.

PD: Los últimos métodos de tu clase (los de comparación) tienen el mismo problema, prueba a comparar dos racionales que uno sea menor que otro pero por menos de una unidad, por ejemplo 1/3 < 1/2, el operador < te va a decir que el primero no es menor que el segundo (porque va a comparar 0 < 0, no 0.3 < 0.5). Suerte

typedef struct tnodo *pnodo; 
// ...
void push_stack(tpila &pila, pnodo nuevo)
 

El parámetro que mandas es <pnodo> y <pnodo> es un puntero a <tnodo>. Al final, lo que estás mandando es un puntero, pero en vez de ser un puntero a una variable es un puntero a un objeto pero no deja de ser un puntero.

Si tus funciones en vez de recibir un <pnodo> (puntero a <tnodo>)  como parámetro, recibiesen un <tnodo> entonces si tendrías que pasarlo por referencia si lo quieres modificar.

No estoy del todo seguro pero si se trata de punteros creo que no es necesario pasarlo por referencia. Esto es porque un puntero contiene una dirección de memoria, no un dato como tal (variable u objeto).
Si se trata de una variable/objeto hay que pasarlo por referencia porque sino se crea una copia al pasarlo por valor y lo que modificamos es la copia, no el original. Pero al tratarse de punteros, estamos pasando una dirección de memoria, entonces aunque se cree una copia del parámetro y se trabaje sobre la copia, la copia es una dirección de memoria (la misma que el puntero original y por esto es que también funciona). Si se quiere reservar memoria sobre un puntero entonces sí hay que pasarlo por referencia.

Por otra parte el tema de que para un BST se pase por referencia es porque así evitas que la función copie todo el BST por valor. Muchas veces se aprovecha el paso por referencia cuando se trabaja con objetos de gran tamaño para evitar que se haga una copia y así ahorrar espacio en memoria. Por eso hay funciones que reciben objetos constantes por referencia, que parece una tontería ya que al ser constante no se puede modificar pero se hace sólo para evitar que la función ocupe el doble de memoria haciendo una copia del objeto. Para objetos pequeños o variables sencillas es indiferente ya que el gasto de memoria es pequeño pero también podría hacerse. Lo más común es hacer esto con objetos que son muy grandes o que son dinámicos por si llegan a ser muy grandes.

El código entre etiquetas de código GeSHi porque cuando usas la i como índice entre corchetes se convierte todo el mensaje de ahí en adelante en cursiva y la i y los corchetes no se ven y no se puede corregir bien el código.

En la función <generarVector()> estás usando asignaciones (un igual "=") donde deberías estar usando comparaciones (dos iguales "=="). No he mirado todo el código en profundidad pero la idea para generar un vector sin valores repetidos es:
- Opción 1
Generas un número aleatorio, recorres los valores que ya has introducido en el vector y si ninguno es igual al nuevo valor generado, lo introduces en el vector, si ya está repetido, generas otro número.
- Opción 2
Vas ordenando cada nuevo valor que introduces y así no tienes que compararlo con todo el vector que ya tienes generado.
PD: Las funciones de tipo <void> no hace falta que le pongas <return>, es raro verlo. Suerte