Newsgroup: it.comp.lang.c
Titolo: Una funzione può restituire due parametri?

Scusate la mia ignoranza, ma è da poco che mi sono (ri)avvicinato al C.
La mia domanda è:
come posso fare in modo che una funzione mi restituisca piu' di un
parametro? Faccio un esempio: solito esempio di scambio di variabili.
--------------------------------------
# include <stdio.h>
void swap (int, int);
main ()
{
int a=1,b=2;
printf ("a=%d, b=%d\n",a,b);
printf ("Ora faccio lo swapping.\n");
swap (a,b);
printf ("a=%d, b=%d\n",a,b);
}
void swap (int prima, int seconda)
{
int temp;
temp=prima;
prima=seconda;
seconda=temp;
a=prima;b=seconda;
}
--------------------------------------
Ovviamente questo programma NON funziona perchè le due variabili integer a e
b sono interne alla funzione main. Dovrei definire una funzione swap che mi
restituisca non uno ma due interi. Come fare? Lo so, è una cazzata, ma io
non lo so fare. Grazie.
-- 
Claudio Massafra
cmas...@libero.it
go to my web site:
http://digilander.iol.it/vinnimur
-- 
Posted from 
mail-4.tiscalinet.it
 [195.130.225.150] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 parametro? 
mai sentito parlare delle struct? e del passaggio di un puntatore?-)

 ha scritto nel messaggio
news:1999686.T...@tin.it...

alla funzione swap non devi passargli due variabili, ma due puntatori
Swap(int *a, int *b)
poi quando richiami la funzione Swap ovviamente devi passargli l'indirizzo
di due variabili, ovvero
Swap(&nome_variabile1, &nome_varaibile2)
altrimenti i due puntatori punterebbero a degli indirizzi di memoria casuale
e crash...

parametro? 
Li racchiudi in una struttura, usata come ritorno.
--
Andrea Laforgia (ICQ 87230455)
http://www.geocities.com/AndreaLaforgia
"ci sono tre tipi di persone nel mondo : quelli che
 sono bravi in matematica e quelli che non lo sono."

 ha scritto nel messaggio
news:et879to295etoed1g...@4ax.com...

perchč una struttura? non sarebbe piů semplice usare due variabili
all'interno della funzione chiamante?
sicuramente mi sfugge qualcosa, dato che sto iniziando adesso...

all'interno della funzione chiamante?
Dipende.
Potrebbe essere piu' semplice passare una struttura contenente dieci
membr, come valore di ritorno, anziche' dieci parametri passati per
riferimento.  Si potrebbe passare la struttura, a sua volta, per
riferimento.  I casi sono diversi e conducono allo stesso risultato.
A mio avviso, e' meglio conservare informazioni "comuni" in un "luogo
comune" (come una struttura).
Nell'esempio seguente e' molto piu' semplice (a mio avviso) definire
una matrice in questo modo :
typedef Matrice_t {
        int    righe ;
        int    colonne ;
        double **dati ;
} ;
e usare una funzione che ne accetta una per riferimento :
void AllocaMatrice( Matrice_t* M, int nrighe, int ncolonne )
{
     M->righe = nrighe ;
     M->colonne = ncolonne ;
     M->dati = malloc( nrighe * ncolonne ) ;
     ...
}
anziche' 
void AllocaMatrice( double ***dati, int nrighe, int ncolonne )
{
     ...
}
Dall'aspetto sicuramente piu' pauroso.
Cosi' come (volendo gestire i dati in modo compatto) si protrebbe
usare il seguente :
Matrice_t ProdottoTraMatrici( Matrice_t A, Matrice_t B )
{
       ...


 fosse diversa.
Ho solo proposto un'alternativa alla restituzione di una stuttura;
modificando leggermente il suo sorgente ottiene il risultato. Ovvio che
esistono 1000 e è strade.
Bye!
--
Peruch Emiliano
SoftWay S.r.l.

> esistono 1000 e è strade.
E' il bello del C: risolvere i problemi in mille modi possibili diversi tra
loro.
Cmq sono io che sono un po' un rompiscatole ;D
Dome

#include <stdio.h>
#include <stdlib.h>
void swap (int *prima, int *seconda);
int main (int argc, char *argv[])
{
int a=1,b=2;
if(argc!=3)
{
    printf("Dammi due parametri\n");
    return 1;
}
a = atoi( argv[1] );
b = atoi( argv[2] );
printf ("a=%d, b=%d\n",a,b);
printf ("Ora faccio lo swapping.\n");
swap (&a,&b); // passo gli indirizzi delle variabili da scambiare
printf ("a=%d, b=%d\n",a,b);
}
void swap (int *prima, int *seconda)
{
int temp;
// *prima = contenuto di prima
temp=*prima;
*prima=*seconda;
*seconda=temp;


#include <stdio.h>
#include <stdlib.h>
void swap (int *prima, int *seconda);
int main (int argc, char *argv[])
{
int a=1,b=2;
if(argc!=3)
{
    printf("Dammi due parametri\n");
    return 1;
}
a = atoi( argv[1] );
b = atoi( argv[2] );
printf ("a=%d, b=%d\n",a,b);
printf ("Ora faccio lo swapping.\n");
swap (&a,&b); // passo gli indirizzi delle variabili da scambiare
printf ("a=%d, b=%d\n",a,b);
}
void swap (int *prima, int *seconda)


#include <stdio.h>
#include <stdlib.h>
void swap (int *prima, int *seconda);
int main (int argc, char *argv[])
{
int a=1,b=2;
if(argc!=3)
{
    printf("Dammi due parametri\n");
    return 1;
}
a = atoi( argv[1] );
b = atoi( argv[2] );
printf ("a=%d, b=%d\n",a,b);
printf ("Ora faccio lo swapping.\n");
swap (&a,&b); // passo gli indirizzi delle variabili da scambiare
printf ("a=%d, b=%d\n",a,b);
}
void swap (int *prima, int *seconda)


1) non capisco perche hai postato il mex 3 volte...
2) ???? non hai mica restituito due parametri! Hai usato i puntatori dati
come argomenti. Il risultato magari č lo stesso, ma credo che la domanda
fosse diversa.
Io avrei una teoria: utilizzare come return value un tipo piů grande del
tipo della variabile utilizzata. Mi spiego:
DWORD MyFunc(...)
{
  DWORD res;
 /*...*/
return res;
}
int main()
{
 WORD a,b;
 DWORD res;
res = MyFunc;
a = HIWORD(res);
b = LOWORD(res);
...
}
ora: magari i tipi sono sbagliatissimi, l'ho buttata giu a cavolo...ora che
ci penso per fare cosi tanto vale usare i puntatori..insomma: sono un
rompiballe!!!! ;P
Dome