Matrici: approccio statico o dinamico?

[frindel]

Ciao a tutti.
Il problema che mi è stato posto è, date due coppie di numeri, (a,b) e (c,d), generare delle matrici casuali A(a,b) e B(c,d).
Una volta fatto questo scrivere, se possibili, la somma A+B, il prodotto AxB e BxA (non è commutativo, si sa...) e le trasposte T(A) e T(B).

Per generare le due matrici uso una funzione

void crea (a,b) che con una rand() mi crea la matrice....Ma!

1. Essendo la funzione void, cioè non rendendo nulla, come faccio poi a riprenderne gli elementi per eseguirci le successive operazioni?

La soluzione sarebbe quella di non usare una funzione void, ma una che mi renda una matrice di interi A[a][b] (analogamente per B). Solo che non so come fare una cosa simile. Chi mi potrebbe aiutare?

I valori a e b non li posso mettere come define, in quanto devo assegnarli io dal programma (sennò sarebbe facile...). Quindi come mi converrebbe agire?

[oregon]

Devi scrivere una funzione che restituisca il puntatore alla matrice allocata dinamicamente

int *crea(int a, int b)
{

}

[frindel]

int *crea (a,b){
 int i,j,A[a][b] ;
 for (i=0;i<a;i++)
     for (j=0;j<b;j++)
          A[i][j]= rand()%100;
return (?) //cosa ritorno?
}

[oregon]

Che vuol dire la tua risposta?

EDIT: forse non l'avevi ancora completata ...

Comunque ... ti avevo detto di allocare la matrice "dinamicamente" ma tu non l'hai fatto ...

P.S. La funzione che ti ho suggerito tratta la matrice come se fosse un vettore di interi ... se vuoi, puoi anche gestirla in maniera diversa scrivendo

int **crea()
{
}

allocando lo spazio tramite un doppio puntatore ...

[frindel]

Non so se hai letto il codice incompleto che ho postato per errore... l'ho modificato col codice completo.

Solo che ok... ho a e b che sono il numero di righe e colonne, chiamo la funzione

int *creamatrice(a,b){
int i,j;
int A[i][j];

for (i=0;i<a;i++)
for (j=0;j<b;j++)
<mi creo la matrice A[i][j] con valori casuali>

return A;
}...


Dovrei fare una cosa del genere?
Oppure allocare lo spazio in maniera dinamica?
In questo caso aiutatemi perché con l'allocazione dinamica ci ho litigato all'asilo...

[oregon]

Sì ... devi usare l'allocazione dinamica ... ma a questo punto ti consiglierei di usare un doppio puntatore ... per risparmiare tempo e messaggi, ti propongo una soluzione ... fammi sapere ...

int **crea(int a, int b)
{
  int i, j;
  int **p = (int **)malloc(a * sizeof(int *));
  for(i=0; i<a; i++)
    *(p+i) = (int *)malloc(b * sizeof(int));

  for (i=0; i<a; i++)
    for (j=0; j<b; j++)
      p[i][j] = rand()%100;

  return (p);
}

void main()
{
   int **n = crea(10, 5);

   // ...
}

Per fare prima, non ho inserito i controlli sulla validita' del puntatore dopo l'allocazione ... (le malloc potrebbero fallire ...) ... pensaci tu ...

[frindel]

MITICO!!!

E' proprio il genere di approccio che stavo cercando. Grazie assai.

Ora col puntatore **p reso dalla funzione posso:

- stampare a video la matrice
- sommare qs matrice con un'altra creata in maniera analoga
- effettuare il prodotto tra matrici e la trasposizione

il tutto secondo quanto mi permettono le regole dell'algebra lineare, ovviamente?

Ti ringrazio...

[frindel]

ok... di nuovo io...
ho la matrice, con il suo bravo puntatore... ora devo stamparla a video:

se faccio printf ("%d",p) non andrei molto lontano: mi stamperebbe tutti i numeri in riga... e io li voglio in formato riga x colonna;

vorrei creare una procedura atta allo scopo: a partire dal puntatore **p mi deve stampare la matrice...

void stampa (int **p){

int a,b,i,j;

a = sizeof (*p); //il numero di righe
b = sizeof (**p); //il numero di colonne

for (i=0;i<a;i++)
for (j=0;j<b;j++)
printf ("%2d ",p);
}

Sbaglio?

[oregon]

Sì ... quei sizeof non possono funzionare ...

In realta' non hai modo di capire quante righe e colonne ci sono a partire dal puntatore ... devi passarle come parametri alla funzione ...

[frindel]

ok... righe e colonne me le posso tirare fuori perché le conosco a priori.

Le ho dichiarate anzitempo con due scanf: una per la matrice A e l'altra per la matrice B.

La funzione che genera le matrici è quella suggeritami da Oregon.

Per stampare ho provato la seguente funzione:

void stampa (**p, a, b){ //p è il puntatore della matrice generata, a e b sono le dimensioni;
int i,j;
for (i=0;i<a;i++)
for (j=0;j<c;j++)
printf("%2d ",p[i][j])
}

A video però mi dà dei numeri assurdi... che dipenda dalla funzione "crea"? Ora provo a postare il listato:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int **creamatrice(int a, int b) {
     int i,j;
     srand(time(NULL));
     
     int **p = (int **)malloc(a * sizeof(int *));
     
     if (!p) exit(1);
        else {
             for (i=0;i<a;i++){
                 *(p+i) = (int *)malloc(b * sizeof(int));
                 if(!(p+i)) exit(1);
                 }
             }
     for (i=0;i<a;i++)
         for (j=0;j<b;j++)
             p[i][j] = rand()%100;
             
             return (p);
     }

void stampa(int **p, int r, int c){
     int i,j;
     for (i=0;i<r;i++)
         for (j=0;j<c;j++)
             printf("%2d",p[i][j]);
     }
         

main() {
       int ar, br, ac, bc, i,j;
              
       puts ("Matrice A.Quante righe? ");
       scanf ("%d", &ar);
       puts ("Quante colonne? ");
       scanf ("%d", &ac);
       
       puts ("Matrice B.Quante righe? ");
       scanf ("%d", &br);
       puts ("Quante colonne? ");
       scanf ("%d", &bc);
       
       int **A = creamatrice (ar,ac);
       int **B = creamatrice (br,bc);   
       
       puts ("\nMatrice A:\n");
       stampa (A,ar,ac);
       puts ("\nMatrice B:\n");
       stampa (B,br,bc);
       
       
        
       fflush (stdin);
       getchar();
       }