[C++] acquisire matrice NxN e cercare zeri su diagonale principale

[pochefuok]

salve a tutti,
mi sono appena registrato e la mia intenzione è quella di imparare sempre più cose sul mondo della programmazione... e ho subito visto di buon occhio questo forum ;D

ho aperto questo topic perchè in questo momento sto esercitandomi un pò con il c++ (senza oggetti come ci è stato proposto all'università...) e venendo dal c (non mi definisco assolutamente un esperto per farvi capire sono arrivato ai puntatori e a qualcosa sui dati strutturati) sono un pò confuso sulle nuove funzioni d usare. l'esercizio che stavo svolgendo chiede di creare una matrice NxN leggendola da tastiera per poi creare una funzione ricorsiva che restituisca 1 se ci sono elementi nulli nella diagonale principale della matrice; 0 altrimenti. credo di aver impostato bene il problema (o almeno lo spero) ma chiaramente ci sono errori in codeblocks che non riesco a decifrare e, nonostante abbia riletto il codice più volte, non sono capace di trovare gli errori:

#include <iostream>
int diagonale_nulla (int A, int n);
using namespace std;
int main ()
{

// dichiarazione e lettura matrice
cout << "inserire grandezza matrice NxN" << endl << "N=?" << endl;
int n;
cin >> n;
int A[n][n];
int i, j;
cout << "inserire elementi matrice NxN" << endl;
for (i=0; i==n-1; i++)
  {
  for (j=0; j==n-1; j++)
    {
    cin >> A[i][j];
    }
  }

// verifica elementi nulli in diagonale principale e stampa del risultato
if (diagonale_nulla (A, n)==0)
  then
  {
  cout << "NON CI SONO elementi nulli nella diagonale principale della tua matrice" << endl;
  }
  else
  {
  cout << "CI SONO elementi nulli nella diagonale principale della tua matrice" << endl;
  }

// stampa diagonale tua per verifica
cout << "la diagonale messa e'" << endl;
for (i=0; i==n-1; i++)
  {
  for (j=0; j==n-1; j++)
    {
    cout << A[i][j];
    }
   cout << endl;
  }
return 0;
}



// funzione ricorsiva usata nel main
int diagonale_nulla (int A, int n)
{
if (n>=0)
  then
  {
  if (A[n][n]==0)
    then
    {
    return 1;
    }
    else
    {
    diagonale_nulla (A, n-1);
    }
  else
  {
  return 0;
  }
}
}

mi piacerebbe ricevere se possibile un aiuto. grazie mille a tutti!

PS: al di là dell'università che ha una struttura "tradizionale" degli argomenti trattati mi consigliate di studiare per bene il c o c++? non sono il tipo che chiede le differenze perchè su internet si trova ovviamente la risposta a questa domanda ma vorrei piuttosto un consiglio perchè mi ritrovo adesso sapendo un pò di c studiato "solamente" per passare e comprendere meglio il c++ (di cui non trattiamo gli "oggetti" durante il corso).
spero di non aver chiesto troppo e soprattutto di non aver infranto limiti del regolamento. mi scuso per l'eventualità.

[Scara95]

non è possibile utilizzare questo costrutto in C++

int A[n][n];

ma solo in C99 e sucessivi (per altro non molto diffusi)...

Devi utilizzare l'allocazione dinamica con new e delete (in stile C++) o malloc/calloc/realloc e free (in stile C)...

Non ho controllato il resto del codice, comunque quando posti il codice posta sempre l'output del compilatore!

Ti conviene apprendere il C++ per presenza di librerie, frameworks et simila ed un utilizzo più orientato al desktop...
Il C se ti orienti più verso i sistemi operativi e i microcontrollori...
Tutto questo è un giudizio generale e molto vago...

[MItaly]

Benvenuto sul forum! Il linguaggio di riferimento va sempre specificato nel titolo, sotto forma di "tag"; inoltre, il titolo dovrebbe contenere una descrizione un po' più significativa del problema.

Ora correggo io, in futuro imposta correttamente la discussione fin da subito; nel frattempo ti consiglio di dare un'occhiata al regolamento.

[pochefuok]

vi ringrazio prima di tutto per avermi risposto e mi scuso per l'imprecisione da primo post

venendo invece all'algoritmo ho scovato prima di tutto un errore e cioè quello dell'uso della parola

then

che logicamente ho sempre usato nei linguaggi di programmazione come il pascal-like per un uso più cartaceo... quindi fuori un errore ma adesso ne rimangono ancora altri... adesso vi posto attualmente il codice di errore che mi ritrovo su codeblocks:

Compiling: /home/pochefuok/Scrivania/Untitled1.cpp
/home/pochefuok/Scrivania/Untitled1.cpp: In function ‘int main()’:
/home/pochefuok/Scrivania/Untitled1.cpp:23: error: invalid conversion from ‘int (*)[(((long unsigned int)(((long int)n) + -0x00000000000000001)) + 1)]’ to ‘int’
/home/pochefuok/Scrivania/Untitled1.cpp:23: error:   initializing argument 2 of ‘int diagonale_nulla(int, int)’
/home/pochefuok/Scrivania/Untitled1.cpp: In function ‘int diagonale_nulla(int, int)’:
/home/pochefuok/Scrivania/Untitled1.cpp:52: error: invalid types ‘int[int]’ for array subscript
/home/pochefuok/Scrivania/Untitled1.cpp:60: error: expected ‘}’ before ‘else’
/home/pochefuok/Scrivania/Untitled1.cpp: At global scope:
/home/pochefuok/Scrivania/Untitled1.cpp:65: error: expected declaration before ‘}’ token
Process terminated with status 1 (0 minutes, 0 seconds)
5 errors, 0 warnings

secondo voi dove stanno gli errori rimanenti??

grazie!

edit: scusate ho editato il post perchè non avevo inserito tutto il build log riferito agli errori di compilazione ma solo una parte... sorry

[oregon]

La funzione

int diagonale_nulla (int A, int n)

accetta come primo parametro un intero, non una matrice di interi ...

[pochefuok]

giusto!

ho corretto un pò il codice nel main e adesso sembrano non ci siano più errori lì ma solo nella seconda parte cioè quando al di fuori del main ho scritto il campione della funzione da utilizzare... adesso quindi bisogna aggiustare solo questa parte di codice

// funzione ricorsiva usata nel main
int diagonale_nulla (int A, int n)
{
if (n>=0)
  {
  if (A[n][n]==0)
    {
    return 1;
    }
    else
    {
    diagonale_nulla (A, n-1);
    }
  else
  {
  return 0;
  }
}
}

ma facendo delle prove non riesco a risolvere... purtroppo mi imbroglio sempre in funzioni che chiamando puntatori... cosa va bene quindi al posto di

int A

????

[minomic]

Ciao, ho fatto qualche correzione. Vedi se ti trovi:

#include <iostream>
using namespace std;

int diagonale_nulla (int[][10], int);

int main () {

// dichiarazione e lettura matrice
cout << "inserire grandezza matrice NxN" << endl << "N=?" << endl;
int n=0;
cin >> n;
int A[n][10];
int i, j;
cout << "inserire elementi matrice NxN" << endl;
for (i=0; i<=n-1; i++)
  {
  for (j=0; j<=n-1; j++)
    {
    cin >> A[i][j];
    }
  }

// verifica elementi nulli in diagonale principale e stampa del risultato
if (diagonale_nulla(A, n)==0)
  {
  cout << "NON CI SONO elementi nulli nella diagonale principale della tua matrice" << endl;
  }
  else
  {
  cout << "CI SONO elementi nulli nella diagonale principale della tua matrice" << endl;
  }

// stampa diagonale tua per verifica
cout << "la diagonale messa e'" << endl;
for (i=0; i<=n-1; i++)
  {
  for (j=0; j<=n-1; j++)
    {
    cout << A[i][j];
    }
   cout << endl;
  }
return 0;
}



// funzione ricorsiva usata nel main
int diagonale_nulla (int A[][10], int n) {
    if (n>=0) {
      if (A[n][n]==0) {
        return 1;
      }
      else {
        diagonale_nulla (A, n-1);
      }
    }
    else {
      return 0;
    }
}

PS. In questo modo però alla fine non stampa la diagonale, ma solo la matrice. Per stampare solo la diagonale ci vuole un controllo in più:

if(i==j)...

[pochefuok]

ho capito ciò che hai fatto ma credo che non vada bene per la mia causa poichè per far risultare i conti (e rendere l'esercizio fattibile per la traccia) bisognerebbe inserire per forza come valore "n", immesso da tastiera, "10"; altrimenti la matrice non sarà della forma quadrata NxN ma Nx10 (il che non mi permetterebbe di controllare la diagonale)
il mio codice un pò corretto adesso è questo:

#include <iostream>
int diagonale_nulla (int n, int **A);
using namespace std;
int main ()
{

// dichiarazione e lettura matrice
cout << "inserire grandezza matrice NxN" << endl << "N=?" << endl;
int n;
cin >> n;
int A[n][n];
int i, j;
cout << "inserire elementi matrice NxN" << endl;
for (i=0; i==n-1; i++)
  {
  for (j=0; j==n-1; j++)
    {
    cin >> A[i][j];
    }
  }

// verifica elementi nulli in diagonale principale e stampa del risultato
if (diagonale_nulla (n, A[n][n])==0)
  {
  cout << "NON CI SONO elementi nulli nella diagonale principale della tua matrice" << endl;
  }
  else
  {
  cout << "CI SONO elementi nulli nella diagonale principale della tua matrice" << endl;
  }

// stampa diagonale tua per verifica
cout << "la diagonale messa e'" << endl;
for (i=0; i==n-1; i++)
  {
  for (j=0; j==n-1; j++)
    {
    cout << A[i][j];
    }
   cout << endl;
  }
return 0;
}



// funzione ricorsiva usata nel main
int diagonale_nulla (int n, int **A)
{
if (n>=0)
  {
  if (A[n][n]==0)
    {
    return 1;
    }
    else
    {
    diagonale_nulla (n-1, A);
    }
  else
  {
  return 0;
  }
}
}

[minomic]

Non è vero: ho appena provato con n=3 e funziona perfettamente.
Ho aggiunto il controllo per far stampare solo la diagonale. Prova un po'...

#include <iostream>
using namespace std;

int diagonale_nulla (int[][10], int);

int main () {

// dichiarazione e lettura matrice
cout << "inserire grandezza matrice NxN" << endl << "N=?" << endl;
int n=0;
cin >> n;
int A[n][10];
int i, j;
cout << "inserire elementi matrice NxN" << endl;
for (i=0; i<=n-1; i++)
  {
  for (j=0; j<=n-1; j++)
    {
    cin >> A[i][j];
    }
  }

// verifica elementi nulli in diagonale principale e stampa del risultato
if (diagonale_nulla(A, n)==0)
  {
  cout << "NON CI SONO elementi nulli nella diagonale principale della tua matrice" << endl;
  }
  else
  {
  cout << "CI SONO elementi nulli nella diagonale principale della tua matrice" << endl;
  }

// stampa diagonale tua per verifica
cout << "la diagonale messa e'" << endl;
for (i=0; i<=n-1; i++)
  {
  for (j=0; j<=n-1; j++)
    {
        if(i==j)
            cout << A[i][j];
    }
   cout << endl;
  }
return 0;
}



// funzione ricorsiva usata nel main
int diagonale_nulla (int A[][10], int n) {
    if (n>=0) {
      if (A[n][n]==0) {
        return 1;
      }
      else {
        diagonale_nulla (A, n-1);
      }
    }
    else {
      return 0;
    }
}

[pochefuok]

io più che altro non metto in dubbio il funzionamento di tutto l'algoritmo ma nello specifico la dichiarazione dell'array: perchè non essendo più di dimensioni NxN ma Nx10 se io non metto N=10 in modo da farlo risultare 10x10, la matrice non è quadrata e quindi è inutile parlare di diagonale... a te funziona ma essendo una matrice 3x10, come nel tuo caso, tu controlli la diagonale della matrice "interna" 3x3 contenuta nella 3x10...