[C] comando return per un vettore di una funzione:

[marco83pt]

Ciao a tutti, anticipo che sarò grato a chi risponderà a questo quesito.

devo creare una funzione che prende un vettore come ingresso e me lo renda in uscita...la devo precare del tipo:

long double xx (long double y[], long double z[]) {

.....
la funzione fa i suoi conti e mi rende un vettore ex r[]
.....

return??????;
}

come faccio a dare a return il comando che mi esporta il vettore???
il metto void all'inizio, ma ho bisogno di scriverla come se fosse uno scalare.
qualcuno mi puoi aiutare?
grazie.marco

[AnonimoVeneziano]

return r;

Però devi stare attento.

Se il vettore lo crei all'interno della funzione ad esempio con

long double r[10];

se fai

return r;

quello che otterrai è che all'uscita della funzione il vettore , in quanto automatico, verrà distrutto e quindi alla funzione chiamante ritornerai un dangling pointer.

Due modi di fare questa cosa sono o dare alla funzione un terzo vettore come parametro dove verrà contenuto il risultato dell'operazione ad esempio :

void funzione(long double x[], long double y[], long double r[])
{
............codice............
     return;
}

oppure allochi con una malloc direttamente da dentro alla funzione il tuo vettore ad esempio

long double* funzione(long double x[], long double y[])
{
     long double *r = (long double *) malloc(sizeof(long double) * 10);
........ codice .......
     return r;
}

Io preferisco di gran lunga la prima opzione, in quanto allocare vettori dentro le funzioni è altamente sconsigliabile in quanto si rischia che vengano creati dei memory leak visto che i vettori creati con malloc dovrebbero essere deallocati con una "free()" dopo l'utilizzo .
Fornendo un vettore alla funzione dove memorizzare il risultato come nel primo caso permette al chiamante di dare in pasto alla funzione un vettore automatico che quindi non necessita di deallocazione con free, ad esempio :

long double r[10];

funzione(x,y,r);

Ciao

[marco83pt]

ho risolto seguendo il tuo primo consiglio.
questo è un esempio

#include<stdio.h>

void xl (long double g[], long double f[]);

void xl (long double g[], long double f[]) {
f[0] = (g[0] + 0.5 * (g[1] - g[0] - g[2]));
f[1] = (g[0] + 0.5 * (g[1] - g[0] + g[2]));
f[2] = g[2];
return;
}
int main () {
long double c[3] = {3,9,1};
int i;
xl(c,c);
for(i=0;i<3;++i)
printf("%Lf ",c[i]);
return(0);
}

praticamente se definiscio la funzione con void ... nella (..) devo mettere il vettore entrante ed uscente
ho capito male o no?

COMUNQUE GRAZIE

[AnonimoVeneziano]

Originariamente inviato da marco83pt

ho risolto seguendo il tuo primo consiglio.
questo è un esempio


praticamente se definiscio la funzione con void ... nella (..) devo mettere il vettore entrante ed uscente
ho capito male o no?

COMUNQUE GRAZIE

Beh, il concetto è quello, ma la tua implementazione mi sembra un po' ... strana.

quando chiami la funzioni crei un solo vettore "c" che usi sia come input sia come output con :

xl(c,c);

Guardando il codice della funzione sinceramente mi chiedo come questa funzione possa ritornare il valore che vuoi dato che cambi i valori di input durante il calcolo.

Sei sicuro che è proprio quello che vuoi fare?

Ciao

[marco83pt]

una volta eseguito il comando

xl(c,c)

il vettore c è stato (modificato).giusto?

è quello che mi serve alla fine, se mi voglio tenere poi anche l'oroginale mi faccio una copia prima e sono ok?
dimmmi se sbaglio.

[AnonimoVeneziano]

Il problema è un altro.

Il codice della funzione è questo :

void xl (long double g[], long double f[]) {
f[0] = (g[0] + 0.5 * (g[1] - g[0] - g[2]));
f[1] = (g[0] + 0.5 * (g[1] - g[0] + g[2]));
f[2] = g[2];
}

f e g sono LO STESSO vettore. Quando fai f[0] = XXXXX anche g[0] viene modificato perchè f e g puntano alla stessa cosa.

Nella seconda espressione (f[1] = XXXX) usi anche g[0] che è stato modificato dalla prima espressione (f[0] = XXXXX).
In pratica in questa espressione :

f[1] = (g[0] + 0.5 * (g[1] - g[0] + g[2]));

g[0] non è più 3 (come specificato nella definizione del vettore "c") , ma è il nuovo valore calcolato nella prima espressione.
Questa non è NECESSARIAMENTE una cosa negativa se voluta.
Il problema è che ho come l'impressione che questo non sia il caso.

Non so se la spiegazione è chiara

Ciao

[marco83pt]

la funzione serve a :
prendo g[]
lo modifico
restituisco g[].
solo che ho chiamato f[] = g[] ;
se , per ex: g(3,9,1)
f0=3+0.5(9-3-1)= -> f(0)=5.5
f1=3+0.5(9-3+1)= -> f(1)=6.5
f2=g2 -> f2=1;

quindi se faccio
g(3,9,1)
xl(g)
g(5.5,6.5,1)

è questo quello che voglio fare!Quindi, presumo di farla in maniera errata.

[marco83pt]

Originariamente inviato da marco83pt

la funzione serve a :
prendo g[]
lo modifico
restituisco g[].
solo che ho chiamato f[] = g[] ;
se , per ex: g(3,9,1)
f0=3+0.5(9-3-1)= -> f(0)=5.5
f1=3+0.5(9-3+1)= -> f(1)=6.5
f2=g2 -> f2=1;

quindi se faccio
g(3,9,1)
xl(g)
g(5.5,6.5,1)

è questo quello che voglio fare!Quindi, presumo di farla in maniera errata.

comunque ho risolto facendo così (smontando in due):
long double xl (long double a, long double b, long double set);
long double xr (long double a, long double b, long double set);

long double xl (long double a, long double b, long double set) {
long double xl;
xl = a + 0.5 (b - a - set);
return xl;
}
long double xr (long double a, long double b, long double set) {
long double xl;
xr = a + 0.5 (b - a + set);
return xr;
}

[AnonimoVeneziano]

Originariamente inviato da marco83pt

la funzione serve a :
prendo g[]
lo modifico
restituisco g[].
solo che ho chiamato f[] = g[] ;
se , per ex: g(3,9,1)
f0=3+0.5(9-3-1)= -> f(0)=5.5
f1=3+0.5(9-3+1)= -> f(1)=6.5
f2=g2 -> f2=1;

quindi se faccio
g(3,9,1)
xl(g)
g(5.5,6.5,1)

è questo quello che voglio fare!Quindi, presumo di farla in maniera errata.

Basta fare così :

#include<stdio.h>

void xl (long double g[], long double f[]);

void xl (long double g[], long double f[]) {
f[0] = (g[0] + 0.5 * (g[1] - g[0] - g[2]));
f[1] = (g[0] + 0.5 * (g[1] - g[0] + g[2]));
f[2] = g[2];
return;
}
int main () {
long double c[3] = {3,9,1};
long double d[3] = {0.0, 0.0, 0.0};
int i;
xl(c,d);
for(i=0;i<3;++i)
printf("%Lf ",d[i]);
return(0);
}