[C] Passare un vettore tramite una procedura

[Composition86]

Salve a tutti, sto cercando di passare il vettore "determinante" alla procedura "cramer" sfruttando la procedura "determinanteQuadrato" (in fondo al programma).

#include <conio.h>
#include <stdio.h>
#include <ctype.h>

typedef struct {
int numeratore;
int denominatore;
} tipoRazionale;

void init (tipoRazionale equazionelineare [2][3]);
void stampaMatrice (tipoRazionale equazionelineare [2][3]);
tipoRazionale differenza (tipoRazionale v1, tipoRazionale v2 );
tipoRazionale prodotto (tipoRazionale v1, tipoRazionale v2 );
tipoRazionale divisione (tipoRazionale v1, tipoRazionale v2 );
void determinanteQuadrato (tipoRazionale equazionelineare [2][3], int i, int j, tipoRazionale *determinante);
void cramer (tipoRazionale equazionelineare [2][3], tipoRazionale soluzione[2], tipoRazionale determinante[1]);
void stampaSoluzione (tipoRazionale soluzione[2]);

void main (void)
{
   tipoRazionale equazioneLineare [2][3], Soluzione[2], Determinante[1];
   char scelta;
   
   do {
       init (equazioneLineare);
       stampaMatrice (equazioneLineare);
       cramer (equazioneLineare, Soluzione, Determinante);
       stampaSoluzione (Soluzione);
       printf ("\nVuoi ripetere il programma? (Digita 'n' per terminare) ");
       scelta=getche();
      } while (tolower(scelta) != 'n');
}

void init (tipoRazionale equazionelineare [2][3])
{
   int i, j, contatore=1;
   
   printf ("Digitare gli elementi della matrice (numeratore e denominatore non nullo):\n\n");
   
   for (i=0 ; i<=1 ; i++) {
      for (j=0 ; j<=2 ; j++, contatore++) {
         printf ("Elemento %d:\n", contatore);
         printf ("Numeratore: ");
         scanf ("%d", &equazionelineare [i][j].numeratore );
         printf ("Denominatore: ");
         scanf ("%d", &equazionelineare [i][j].denominatore );
         printf ("\n");
      }
   }
}

void stampaMatrice (tipoRazionale equazionelineare [2][3])
{
   int i, j;
   
   printf ("\nLa matrice inizializzata e':\n\n");
   
   for (i=0 ; i<=1 ; i++) {
      for (j=0 ; j<=2 ; j++) {
         printf ("%d/%d  ", equazionelineare[i][j].numeratore, equazionelineare[i][j].denominatore );
      }
      printf ("\n");
   }
   
   printf ("\nEquivalente al sistema:\n\n");
   
   printf ("(%d/%d)X + (%d/%d)Y = %d/%d \n", equazionelineare[0][0].numeratore, equazionelineare[0][0].denominatore , equazionelineare[0][1].numeratore, equazionelineare[0][1].denominatore, equazionelineare[0][2].numeratore, equazionelineare[0][2].denominatore);
   printf ("(%d/%d)X + (%d/%d)Y = %d/%d \n", equazionelineare[1][0].numeratore, equazionelineare[1][0].denominatore , equazionelineare[1][1].numeratore, equazionelineare[1][1].denominatore, equazionelineare[1][2].numeratore, equazionelineare[1][2].denominatore);
}

tipoRazionale differenza (tipoRazionale v1, tipoRazionale v2)
{
   tipoRazionale v;
   
   v.numeratore = v2.denominatore * v1.numeratore - v1.denominatore * v2.numeratore;
   v.denominatore = v1.denominatore * v1.denominatore;
   
   return v;
}

tipoRazionale prodotto (tipoRazionale v1, tipoRazionale v2)
{
   tipoRazionale v;
   
   v.numeratore = v2.numeratore * v1.numeratore;
   v.denominatore = v1.denominatore * v1.denominatore;
   
   return v;
}

tipoRazionale divisione (tipoRazionale v1, tipoRazionale v2)
{
   tipoRazionale v;
   
   v.numeratore = v1.numeratore * v2.denominatore;
   v.denominatore = v1.denominatore * v2.numeratore;
   
   return v;
}

void determinanteQuadrato (tipoRazionale equazionelineare [2][3], int i, int j, tipoRazionale *determinante)
{
   
   differenza ( prodotto(equazionelineare[0][i], equazionelineare [1][j]) , prodotto(equazionelineare[0][j], equazionelineare [1][i]) );
}

void cramer (tipoRazionale equazionelineare [2][3], tipoRazionale soluzione[2], tipoRazionale determinante[1])
{
   soluzione[0] = divisione ( determinanteQuadrato( equazionelineare, 2, 1, determinante) , determinanteQuadrato( equazionelineare, 0, 1, determinante) );
   soluzione[1] = divisione ( determinanteQuadrato( equazionelineare, 0, 2, determinante) , determinanteQuadrato( equazionelineare, 0, 1, determinante) );
}

void stampaSoluzione (tipoRazionale soluzione[2])
{
   printf ("\nLe soluzioni del sistema sono X = %d/%d ed Y = %d/%d. \n", soluzione[0].numeratore, soluzione[0].denominatore, soluzione[1].numeratore, soluzione[1].denominatore);
}

Ottengo errori di questo tipo (tutti interni alla procedura "cramer"):

E2342 Type mismatch in parameter 'v1' (wanted 'tipoRazionale', got 'undefined')

E2468 Value of type void is not allowed

Mi sapreste aiutare? Grazie in anticipo.

[DanieleC88]

Originariamente inviato da Composition86

tipoRazionale divisione (tipoRazionale v1, tipoRazionale v2)
{
   tipoRazionale v;
   
   v.numeratore = v1.numeratore * v2.denominatore;
   v.denominatore = v1.denominatore * v2.numeratore;
   
   return v;
}

void determinanteQuadrato (tipoRazionale equazionelineare [2][3], int i, int j, tipoRazionale *determinante)
{
   
   differenza ( prodotto(equazionelineare[0][i], equazionelineare [1][j]) , prodotto(equazionelineare[0][j], equazionelineare [1][i]) );
}

void cramer (tipoRazionale equazionelineare [2][3], tipoRazionale soluzione[2], tipoRazionale determinante[1])
{
   soluzione[0] = divisione ( determinanteQuadrato( equazionelineare, 2, 1, determinante) , determinanteQuadrato( equazionelineare, 0, 1, determinante) );
   soluzione[1] = divisione ( determinanteQuadrato( equazionelineare, 0, 2, determinante) , determinanteQuadrato( equazionelineare, 0, 1, determinante) );
}

È un type mismatch, passi il valore di ritorno di una funzione che restituisce nulla (void) ad una funzione che si aspetta un tipoRazionale.

[Composition86]

Ciao, temo di essermi perso purtroppo.
Ho fatto queste modifiche:

void divisione (tipoRazionale v1, tipoRazionale v2, tipoRazionale v)
{
   v.numeratore = v1.numeratore * v2.denominatore;
   v.denominatore = v1.denominatore * v2.numeratore;
}

void determinanteQuadrato (tipoRazionale equazionelineare [2][3], int i, int j, tipoRazionale *determinante)
{
   
   differenza ( prodotto(equazionelineare[0][i], equazionelineare [1][j]) , prodotto(equazionelineare[0][j], equazionelineare [1][i]) );
}

void cramer (tipoRazionale equazionelineare [2][3], tipoRazionale soluzione[2], tipoRazionale determinante[1], tipoRazionale *v)
{
   soluzione[0] = divisione ( determinanteQuadrato( equazionelineare, 2, 1, determinante) , determinanteQuadrato( equazionelineare, 0, 1, determinante), *v );
   soluzione[1] = divisione ( determinanteQuadrato( equazionelineare, 0, 2, determinante) , determinanteQuadrato( equazionelineare, 0, 1, determinante), *v );
   
   printf ("\nLe soluzioni del sistema sono X = %d/%d ed Y = %d/%d .\n", soluzione[0].numeratore, soluzione[0].denominatore, soluzione[1].numeratore, soluzione[1].denominatore);
}

In "cramer" ho modifcato i due risultati, aumentando gli argomenti di "divisione" (ho aggiunto "v").
Ma così le cose si sono complicate: dovrei anche passare una variabile di tipoRazionale a "cramer" tramite la procedura "divisione".
Ottengo lo stesso tipo di errori.

[DanieleC88]

Aspetta, mi sa che non hai capito qual è l'errore: quando tu chiami divisione() le stai passando come parametri i valori di ritorno di determinanteQuadrato()... che però restituisce dei void! Come può essere un valore accettabile?

ciao

[Composition86]

Ok, ho comunque fatto un po' di casino con l'ultimo programma creato, possiamo ignorarlo.

Provo a dire meglio il mio problema: vorrei fare in modo che la procedura determinanteQuadrato() non restituisca appunto nessun valore, ma passi "in qualche modo" il valore assunto dal determinante alla procedura cramer().
Ciò dovrebbe avvenire nello stesso modo in cui ho passato alla procedura stampaSoluzione() il vettore soluzione[2] elaborato dalla procedura cramer(): in cramer() infatti non c'è un "return soluzione[2]" (che non sarebbe possibile neanche) ma c'è il void.

Il problema che incontro con determinanteQuadrato() è che, per fare quanto detto, dovrei fargli restituire il void che, come mi hai fatto notare, la procedura divisione() non sa gestire perchè si aspetta dei valori di tipo tipoRazionale. Qui mi blocco, tento di sistemare ma ottengo catene di errori.

Tutto questo casino è dovuto alla richiesta della traccia, sull'uso di procedure anzichè di funzioni (con cui invece avevo già realizzato facilmente il programma).

[DanieleC88]

Be', la soluzione è un po' più lunga ma comunque semplice: se tu hai un'operazione che richiede due operandi e dà un risultato, puoi avere un prototipo simile a questo (faccio l'esempio dell'addizione su un generico tipo di dato T):

void operazione(T operando1, T operando2, T *risultato)
{
    (*risultato) = operando1 + operando2;
}

Per fare ciò che ti serve devi semplicemente usare delle variabili di appoggio. Per esempio, utilizzando la stessa funzione per realizzare (3 + 7) + (5 + 2) potresti fare:

void somma(T *risultato)
{
    T r1, r2;

    operazione(3, 7, &r1);
    operazione(5, 2, &r2);
    operazione(r1, r2, risultato);
}

Alla fine dovresti avere un 17 nella memoria puntata dal parametro risultato, e così anche la funzione chiamante vedrebbe le modifiche effettuate. Se ci pensi, in effetti, si tratta solo di rendere espliciti tutti i calcoli intermedi che con dei valori di ritorno non nulli faresti in maniera implicita.

ciao

[Composition86]

Ho eseguito le tue istruzioni, facendo qualche passo avanti:

void divisione (tipoRazionale v1, tipoRazionale v2, tipoRazionale *v)
{ 
   v->numeratore = v1.numeratore * v2.denominatore; 
   (*v).denominatore = v1.denominatore * v2.numeratore;
}

void determinanteQuadrato (tipoRazionale equazionelineare [2][3], int i, int j, tipoRazionale *determinante)
{
   (*determinante) = differenza ( prodotto(equazionelineare[0][i], equazionelineare [1][j]) , prodotto(equazionelineare[0][j], equazionelineare [1][i])); //Non c'è return, ma c'è asterisco determinante
}

void cramer (tipoRazionale equazionelineare [2][3], tipoRazionale *determinante, tipoRazionale *soluzione)
{
   tipoRazionale d1, d2, vtot;
   
   soluzione[0] = divisione ( determinanteQuadrato( equazionelineare, 2, 1, &d1) , determinanteQuadrato( equazionelineare, 0, 1, &d2), &vtot );
   soluzione[1] = divisione ( determinanteQuadrato( equazionelineare, 0, 2, &d1) , determinanteQuadrato( equazionelineare, 0, 1, &d2), &vtot );
}

void stampaSoluzione (tipoRazionale soluzione[2])
{
   printf ("\nLe soluzioni del sistema sono X = %d/%d ed Y = %d/%d. \n", soluzione[0].numeratore, soluzione[0].denominatore, soluzione[1].numeratore, soluzione[1].denominatore);
}

Purtroppo però ottengo sempre degli errori in quelle due righe della procedura cramer(), pensavo di non aver sbagliato stavolta: il programma funzionava bene modificando solo la procedura determinanteQuadrato() e lasciando inalterata la funzione divisione(), forse sbaglio qualcosa con i puntatori in divisione().

[DanieleC88]

Aspetta, non hai capito una cosa però: tu devi prima chiamare la funzione che calcola il risultato intermedio, poi passare i valori calcolati (non il valore di ritorno della funzione) come parametri della funzione che ti interessa.

Riguarda bene il mio esempio e guarda in cosa differisce da ciò che hai fatto.

[Composition86]

Ora ho capito cosa intendi, ma non capisco come adattarlo a questa situazione, in cui ci sono procedure dentro procedure.
Qui poi non è un'addizione di due risultati intermedi, sono due divisioni indipendenti, in più non so se dovrei fare la stessa cosa anche con determinanteQuadrato(): a questo punto a meno di procedere a tentativi non so proprio che fare.

Mi sembra poi strana una cosa: mi era stato spiegato tempo fa come fare a risolvere un esercizio simile, se non avevo capito male si poteva evitare l'uso di risultati intermedi e procedere con una forma più compatta.

[DanieleC88]

Io intendevo una cosa del genere:

void cramer (tipoRazionale equazionelineare [2][3], tipoRazionale *determinante, tipoRazionale *soluzione)
{
   tipoRazionale d1, d2, vtot;
   
   determinanteQuadrato( equazionelineare, 2, 1, &d1);
   determinanteQuadrato( equazionelineare, 0, 1, &d2);
   divisione ( d1 , d2, &vtot );
   soluzione[0] = vtot;

   determinanteQuadrato( equazionelineare, 0, 2, &d1);
   determinanteQuadrato( equazionelineare, 0, 1, &d2);
   divisione ( d1 , d2, &vtot );
   soluzione[1] = vtot;
}

Ovviamente sì, puoi evitare i passaggi intermedi utilizzando i valori di ritorno delle procedure, ma se l'esercizio ti chiede di fare in questo modo...

[Composition86]

Ammetto che risolverlo in questo modo era più facile di ciò che pensavo. TI ringrazio come sempre per competenza e celerità.

Per completezza riporto il programma finale funzionante.

#include <conio.h>
#include <stdio.h>
#include <ctype.h>

typedef struct {
int numeratore;
int denominatore;
} tipoRazionale;

void init (tipoRazionale equazionelineare [2][3]);
void stampaMatrice (tipoRazionale equazionelineare [2][3]);
void somma (tipoRazionale v1, tipoRazionale v2, tipoRazionale *v);
void differenza (tipoRazionale v1, tipoRazionale v2, tipoRazionale *v);
void prodotto (tipoRazionale v1, tipoRazionale v2, tipoRazionale *v);
void divisione (tipoRazionale v1, tipoRazionale v2, tipoRazionale *v);
void determinanteQuadrato (tipoRazionale equazionelineare [2][3], int i, int j, tipoRazionale *determinante);
void cramer (tipoRazionale equazionelineare [2][3], tipoRazionale *determinante, tipoRazionale *soluzione);
void stampaSoluzione (tipoRazionale soluzione[2]);

main()
{
   tipoRazionale equazioneLineare [2][3], Soluzione[2], Determinante;
   char scelta;
   
   do {
       init (equazioneLineare);
       stampaMatrice (equazioneLineare);
       cramer (equazioneLineare, &Determinante, Soluzione);
       stampaSoluzione (Soluzione);
       
       printf ("\nVuoi ripetere il programma? (Digita 'n' per terminare) ");
       scelta=getche();
      } while (tolower(scelta) != 'n');
}

void init (tipoRazionale equazionelineare [2][3])
{
   int i, j, contatore=1;
   
   printf ("Digitare gli elementi della matrice (numeratore e denominatore non nullo):\n\n");
   
   for (i=0 ; i<=1 ; i++) {
      for (j=0 ; j<=2 ; j++, contatore++) {
         printf ("Elemento %d:\n", contatore);
         printf ("Numeratore: ");
         scanf ("%d", &equazionelineare [i][j].numeratore );
         printf ("Denominatore: ");
         scanf ("%d", &equazionelineare [i][j].denominatore );
         printf ("\n");
      }
   }
}

void stampaMatrice (tipoRazionale equazionelineare [2][3])
{
   int i, j;
   
   printf ("\nLa matrice inizializzata e':\n\n");
   
   for (i=0 ; i<=1 ; i++) {
      for (j=0 ; j<=2 ; j++) {
         printf ("%d/%d  ", equazionelineare[i][j].numeratore, equazionelineare[i][j].denominatore );
      }
      printf ("\n");
   }
   
   printf ("\nEquivalente al sistema:\n\n");
   
   printf ("(%d/%d)X + (%d/%d)Y = %d/%d \n", equazionelineare[0][0].numeratore, equazionelineare[0][0].denominatore , equazionelineare[0][1].numeratore, equazionelineare[0][1].denominatore, equazionelineare[0][2].numeratore, equazionelineare[0][2].denominatore);
   printf ("(%d/%d)X + (%d/%d)Y = %d/%d \n", equazionelineare[1][0].numeratore, equazionelineare[1][0].denominatore , equazionelineare[1][1].numeratore, equazionelineare[1][1].denominatore, equazionelineare[1][2].numeratore, equazionelineare[1][2].denominatore);
}

void somma (tipoRazionale v1, tipoRazionale v2, tipoRazionale *v)
{ 
   v->numeratore = v2.denominatore * v1.numeratore + v1.denominatore * v2.numeratore;
   v->denominatore = v1.denominatore * v1.denominatore;
}

void differenza (tipoRazionale v1, tipoRazionale v2, tipoRazionale *v)
{
   v->numeratore = v2.denominatore * v1.numeratore - v1.denominatore * v2.numeratore;
   v->denominatore = v1.denominatore * v1.denominatore;
}

void prodotto (tipoRazionale v1, tipoRazionale v2, tipoRazionale *v)
{
   v->numeratore = v2.numeratore * v1.numeratore;
   v->denominatore = v1.denominatore * v1.denominatore;
}

void divisione (tipoRazionale v1, tipoRazionale v2, tipoRazionale *v)
{ 
   v->numeratore = v1.numeratore * v2.denominatore; //Due forme equivalenti
   (*v).denominatore = v1.denominatore * v2.numeratore;
}

void determinanteQuadrato (tipoRazionale equazionelineare [2][3], int i, int j, tipoRazionale *determinante)
{
   tipoRazionale p1, p2, ptot;
   
   prodotto(equazionelineare[0][i], equazionelineare [1][j], &p1);
   prodotto(equazionelineare[0][j], equazionelineare [1][i], &p2);
   differenza (p1, p2, &ptot);
   (*determinante) = ptot;
}

void cramer (tipoRazionale equazionelineare [2][3], tipoRazionale *determinante, tipoRazionale *soluzione)
{
   tipoRazionale d1, d2, dtot;

   determinanteQuadrato( equazionelineare, 2, 1, &d1);
   determinanteQuadrato( equazionelineare, 0, 1, &d2);
   divisione ( d1 , d2, &dtot );
   soluzione[0] = dtot;

   determinanteQuadrato( equazionelineare, 0, 2, &d1);
   determinanteQuadrato( equazionelineare, 0, 1, &d2);
   divisione ( d1 , d2, &dtot );
   soluzione[1] = dtot;
}

void stampaSoluzione (tipoRazionale soluzione[2])
{
   printf ("\nLe soluzioni del sistema sono X = %d/%d ed Y = %d/%d. \n", soluzione[0].numeratore, soluzione[0].denominatore, soluzione[1].numeratore, soluzione[1].denominatore);
}