[C++] Confronto delle diagonali principali di matrici

Salve a tutti,
io avrei bisogno di un aiuto per un programma che mi chiede di verificare se nelle due diagonali principali di una matrice siano contenuti gli stessi numeri, e se per caso uno non fosse contenuto dovrei stamparlo.
Vi posto il codice che sono riuscito a scrivere finora:

Codice:

#include<iostream>
using namespace std;
main()
{
    cout<<"start"<<endl;

    int d1, d2;  // in d1 pensavo di salvare il primo numero non contenuto nella diagonale secondaria, in d2 quello della principale
   
    bool trovato = false; // inizializzo a false la variabile boolena perché non ho ancora trovato numeri non presenti nei 2 array
   
    int A[6][6];
    for(int i=0; i<6; i=i+1)
        for(int j=0; j<6; j=j+1)
            cin >> A[i][j];             // per riempire da cin la matrice 6x6
   
    for(int i=0; i<6; i++)     // qui pensavo di scorrere con i la diagonale principale e con j quella secondaria per confrontare cosi
    {                                  // [0][0] con [0][5], [1][4], [2][3], [3][2] [4][1], [5][0] e poi proseguire con
//                                        [1][1] con [0][5], [1][4], [2][3], [3][2] [4][1], [5][0] e cosi via fino a [5][5]
        for(int j=0; j<6; j++)
        {
            if(A[i][i] != A[j][5-j]) // qui ho pensato che appena trova un numero della diagonale non contenuto in quella secondaria
            {                               // metta il flag a true, che salvi il valore della diagonale principale in d1 e che esca dal ciclo
                trovato= true;       // perché a me interessa solo il primo che trova, non tutti
                d1 = A[i][i];
                break;
            }
        }
    }

// qui stessa cosa ma confrontando la secondaria con la principale e salvare in d2 il primo non contenuto nella principale

    for(int i=0; i<6; i++)
    {
        for(int j=0; j<6; j++)
        {
            if(A[i][i-5] != A[j][j])
            {
                trovato= true;
                d2 = A[i][i-5];
                break;
            }
        }
    }
   
    if(!trovato)
        cout <<"le due diagonali contengono gli stessi valori" << endl;
    else
    {
        cout<<"diagonale principale contiene "<< d1 <<" che non e' sulla diagonale secondaria" << endl;
        cout<<"diagonale secondaria contiene "<< d2 <<" che non e' sulla diagonale principale" << endl;
    }
   
    cout <<"end"<<endl;
}


Ciao, allora
primo consiglio: invece di riempire il codice di costanti numeriche tipo 6 piuttosto che 5, ti conviene definirti una costante simbolica con la direttiva define o con una costante diretta.

Codice:

 #define N 6 // costante simbolica
const int dim = 6;  // costante da definire nel main 

così se vuoi ridimensionare la matrice ti basta solo modificare il valore di N; già nel tuo codice il 6 compare spesso e modificarlo è molto oneroso.... lascia fare tutto al preprocessore
sostituisci al posto di 6 il valore N, al posto di 5 metti N-1... parametrizzati tutto

in ogni caso credo l'errore sia alle righe 40 e 43 hai messo i-5 invece che 5-i, in questo modo ottieni indici negativi e vai fuori dalla matrice

Eh purtroppo non mi trova nemmeno d1 giusto quindi non credo sia questo l'errore, non so se il ragionamento sia corretto

prova questo codice

Codice:

#include<iostream>
using namespace std;
main()
{
    cout<<"start"<<endl;

    int d1, d2;  // in d1 pensavo di salvare il primo numero non contenuto nella diagonale secondaria, in d2 quello della principale

    bool trovato = false; // inizializzo a false la variabile boolena perché non ho ancora trovato numeri non presenti nei 2 array

    int A[6][6];
    for(int i=0; i<6; i=i+1) {
            cout<<"riga "<<i<<endl;
        for(int j=0; j<6; j=j+1)
            cin >> A[i][j];
                       // per riempire da cin la matrice 6x6
    }

    for(int i=0; i<6  && !trovato ; i++)     // qui pensavo di scorrere con i la diagonale principale e con j quella secondaria per confrontare cosi
    {                                  // [0][0] con [0][5], [1][4], [2][3], [3][2] [4][1], [5][0] e poi proseguire con
//                                        [1][1] con [0][5], [1][4], [2][3], [3][2] [4][1], [5][0] e cosi via fino a [5][5]
        for(int j=0; j<6 && !trovato; j++)
        {
            if(A[i][i] != A[j][5-j]) // qui ho pensato che appena trova un numero della diagonale non contenuto in quella secondaria
            {                               // metta il flag a true, che salvi il valore della diagonale principale in d1 e che esca dal ciclo
                trovato = true;       // perché a me interessa solo il primo che trova, non tutti
                d1 = A[i][i];
            }
        }
    }

    trovato = false;
// qui stessa cosa ma confrontando la secondaria con la principale e salvare in d2 il primo non contenuto nella principale

    for(int i=0; i<6  && !trovato; i++)
    {
        for(int j=0; j<6  && !trovato; j++)
        {
            if(A[i][5-i] != A[j][j])
            {
                trovato= true;
                d2 = A[i][5-i];
            }
        }
    }

    if(!trovato)
        cout <<"le due diagonali contengono gli stessi valori" << endl;
    else
    {
        cout<<"diagonale principale contiene "<< d1 <<" che non e' sulla diagonale secondaria" << endl;
        cout<<"diagonale secondaria contiene "<< d2 <<" che non e' sulla diagonale principale" << endl;
    }

    cout <<"end"<<endl;
}


Hai anche http://en.cppreference.com/w/cpp/language/constexpr nel C++11

L'uso dei #define per definire costanti è molto comune nel C, ma molto meno nel C++ (a livello professionale). Esistono varie alternative all'uso dei #define per la definizioni di costanti:
1) Variabili(locali) Non possono essere usate per definire la dimensione di array statici o i parametri di template ma i compilatori sono in genere capaci di capire se una variabile locale non cambia. Quindi sono spesso convertiti in costanti in fase di compilazione. Questo discorso spesso non vale per le variabili globali.
2) Variabili const(locale, globale static o variabile static in classi o strutture) Come sopra ma aggiunge un maggior numero di controlli statici. Se la variabile è globale e condivisa su più file allora è più improbabile che il compilatore la ottimizzi. Generalmente consigliata rispetto all'opzione 1.
3) variabile dentro un tipo enum questa opzione è più comune di quanto si possa pensare, è sostanzialmente come usare il #define ma è assicurato che il valore sia un intero (dal C++11 si può anche definire il suo tipo). Non può essere usata per valori diversi da interi. Con qualche "trucco" usando i template si può generare questa variabile in tempo di compilazione. Può essere usata per definire array statici o i parametri di template.
4) constexpr è la soluzione migliore in quanto ha i vantaggi dell'enum senza aver i suoi svantaggi ed inotre può essere usata per oggetti molto più complessi di quelli definibili con #define. D'altra parte il supporto al constexpr (in particolare alle funzioni constexpr) è stato lento ed è quindi usato meno di quanto si potrebbe pensare. In particolare richiede che il progetto abbia come requisiti minimi gcc >= 4.6 e/o Visual Studio >= 2015. La potenza di constexpr aumenta ogni nuova versione del C++, ma i compilatori non sono rapidissimi ad aggiungere questi aspetti.

Una costante definita con #define o in un enum sono generalmente pensate come globali. Per cose più locali penso che constexpr e variabili siano scelte migliori.

Constexpr del C++11... oramai i vari compiler lo supportano dai

Nel mio attuale ufficio viene usato Red Hat 6.6 e non possiamo installare nulla.. C++11 non è supportato in tale ambiente. Anche altre società so che usano un ambiente simile (e non sto parlando di società piccole..).

fair enough.
Noi lo si usa tranquillamente

Suppongo che in generale dipenda dal tipo di azienda e dal settore in cui si lavora. Il software prodotto dalla mia azienda non è distribuito all'esterno, ma usato in produzione. La priorità é che la produzione possa continuare senza interruzioni e aggiornare il software è qualcosa di costoso e lento. Si può fare solo in determinati momenti e in modo estremamente graduale. Considera che in passato (stiamo parlando di un paio di anni fa in un'altra azienda) mi è capitato di assistere ad un aggiornamente da AIX a RedHat 6 (c'era già la versione 7 da un po') perché il software usato non supportava più tale macchina! Ci sarà sempre quello che è più lento degli altri ad aggiornare il software.. Ma per una persona che inizia ora non ha ovviamente senso evitare il C++11.