Buenos días. El problema me surge a la hora de rellenar la matriz puesto que me pide dos veces que ingrese los datos. Os adjunto el ejercicio entero por si alguien quisiera echarle una ojeada.


Gracias por tu tiempo.

Unos consejos geniales. Tomaré nota.

¿A qué te refieres con cambiar la función void pedirDatos() por void pedirDatos(int &nFil, int &nCol)?

Imagino que te refieres al paso de parámetros por referencia para así poder incluir las variables dentro del main.

Bien detectado el fallo de control típico de un novato (más aún si cabe  ) en la función matrizCuadrada.

Cómo no se iba a repetir si efectivamente tenía llamadas a la función en el main y en la propia función... 

Perdona si he cometido errores en la publicación, aún tengo que familiarizarme. 

Ahora ya funciona pero si te has dado cuenta, pides los datos dos veces seguidas. Una vez en el <main> y otra vez en la función <matrizCuadrada()>...
Te comento las diferencias entre el filtro <do while> y el <while> ya que esto se puede hacer de ambas formas.

Un bloque de código dentro de un <do while> siempre se ejecuta al menos una vez aunque la condición sea falsa ya que primero está el <do> y luego el <while>. Es como "primero haces y luego compruebas". En cambio un <while> es justo lo contrario; "primero compruebas y luego ya si eso, haces".

Aquí te muestro un bloque infinito. ¿Por qué si la condición de primeras no se cumple? Pues porque primero mostramos el 0, luego lo incrementamos <iteracion = 1> y luego comprobamos si es mayor que 0. Y como sí que lo es pues ya se ejecuta de forma infinita.

int iteracion = 0;
do{
    cout << iteracion << endl;
    iteracion++;
}   while(iteracion > 0); 

Lo mismo con un <while>. La parte interna del bucle nunca se ejecuta. Al principio iteracion vale 0, comprobamos si es mayor que 0 y como no lo es, se acabó.

int iteracion = 0;
while(iteracion > 0){
    cout << iteracion << endl;
    iteracion++;
} 

Entonces ahora te muestro las opciones que tienes:

• Alternativa 1: Pedir los datos únicamente dentro de <matrizCuadrada()>. Entonces sería con un <do while>.

void matrizCuadrada(int m[][TAM], int &nFil, int &nCol){
    do{
        pedirDatos(nFil, nCol);
    }   while(nFil != nCol);
    // el resto de la funcion
} 

• Alternativa 2: Pedir los datos en el <main> y dentro de la función <matrizCuadrada()> comprobarlos para que si no son iguales los pida de nuevo.

void matrizCuadrada(int m[][TAM], int &nFil, int &nCol){
    while(nFil != nCol)
        pedirDatos(nFil, nCol);
    // el resto de la funcion
} 

• Alternativa 3: La más correcta creo yo. Para no tener que ir pasando siempre las dimensiones por referencia, que podrías acabar modificándolas sin querer; haz el filtro dentro de <pedirDatos()> y así te aseguras que cuando acaba esa función la matriz ya es cuadrada.

void pedirDatos(int &nFil, int &nCol){
    do{
        cout << "Introduce las dimensiones de la matriz (NxN): ";
        cin >> nFil >> nCol;
    }   while(nFil != nCol);
} 

Con esta última opción ya no tienes que usar siempre el paso por referencia y así evitar errores mayores.

Es más, yo dejaría el esquema general del programa en algo así :

void pedirDatos(int&, int&);
void generarMatriz(int [][TAM], const int, const int);
void mostrarMatriz(const int [][TAM], const int, const int);
bool esSimetrica(const int [][TAM], const int, const int); 

En el caso de <esSimetrica()>. Cuando se usa una función para comprobar algo es mejor que devuelva <true/false> y luego tú ya verás lo que haces con ello. Imagina un programa muy grande donde tienes que comprobar si 100 matrices son simétricas y vas mostrando por pantalla el resultado de cada una, cuando no es necesario.
Entonces es mejor hacer que devuelva un <bool> de si es simétrica o no y ya en el <main> haces lo que quieras. Algo así:

bool esSimetrica(const int matriz[][TAM], const int nFil, const int nCol){
    bool simetrica = true;
    for(size_t i = 0; i < nFil && simetrica; i++)
        for(size_t j = 0; j < nCol && simetrica; j++)
            simetrica = matriz[i][j] == matriz[j][i];
    return simetrica;
}
 
int main(){
    // todo el programa
    if(esSimetrica(matriz, nFil, nCol))
        cout << "La matriz es simetrica" << endl;
    else
        cout << "La matriz no es simetrica" << endl;
} 

Primero: lo de usar <TAM> es para evitar "números mágicos" (magic numbers) que son números que aparecen por el código literalmente y que es difícil ver a qué están haciendo referencia. Siempre es mejor guardar esos valores en constantes y así en el caso de querer modificar el tamaño/alcance del programa, sólo tendrás que modificar el valor de la constante.
Te muestro un código muy sencillo donde guardamos un array y luego lo mostramos. Imagina el caso que queremos que el programa en vez de almacenar 10 valores, ahora queremos que almacene un máximo de 20... En el primer código tendríamos que cambiar cada 10 por 20; mientras que en el segundo bastaría con cambiar el valor de <TAM>

// version 1 usando numero magicos
int main(){
    int my_array[10];
    for(size_t i = 0; i < 10; i++){
        cout << "Elemento " << i+1 << ": ";
        cin >> my_array[i];
    }
    for(size_t i = 0; i < 10; i++)
        cout << my_array[i] << endl;
}
 
// version 2 usando constantes
const int TAM = 10;
int main(){
    int my_array[TAM];
    for(size_t i = 0; i < TAM; i++){
        cout << "Elemento " << i+1 << ": ";
        cin >> my_array[i];
    }
    for(size_t i = 0; i < TAM; i++)
        cout << my_array[i] << endl;
} 

Otra buena utilidad es cuando todavía no sabemos usar memoria dinámica, es decir; que si queremos que el usuario introduzca n datos pero no sabemos cuánto va a valer n hasta el tiempo de ejecución, podemos crear un máximo para declarar el array y luego controlar la cantidad de valores que va a usar el usuario con otra variable. Se desperdicia memoria pero es la forma de hacerlo con memoria estática. Te dejo aquí un ejemplo:

const int TAM_MAX = 100;
int main(){
    int my_array[TAM_MAX];
    int tam_util;
    cout << "Numero de datos a almacenar: ";
    cin >> tam_util;
    for(size_t i = 0; i < tam_util; i++){ // no usamos TAM_MAX, sino tam_util
        // el resto del bloque
    }
} 

---

Respecto al tema del aprendizaje, al final lo importante es que vayas practicando todo lo que vas viendo, si te limitas a ver códigos hechos nunca sabrás tratar con los errores que te van a surgir cuando seas tú quien los escriba. Siempre habrá temas más importantes que vas a usar en prácticamente todos los programas que hagas y otras cosas que no usarás casi nunca. Para empezar a programar tampoco necesitas haber memorizado TODO antes. Es suficiente con que sepas qué cosas se pueden hacer y cuando necesites usar algo poco común siempre podrás buscar por internet o en libros cómo se usaba eso que quieres implementar.
Normalmente los tutoriales que van por "capítulos" suelen ir bien estructurados para que la curva de aprendizaje no sea muy grande y te van metiendo conceptos poco a poco. Simplemente seguir aprendiendo e ir probando todo lo que vas viendo. Suerte