passaggio array a subroutine

[ant21]

Salve a tutti,

altro piccolo OT,

come faccio a passare da una subroutine due o più array per riferimento e poi trattarli nella subroutine chiamata singolarmente?

mi spiego meglio

subchiamante(\@a, \@b, \@c)

e nella procedura chiamata come faccio a manipolare singolarmente gli array?

con @_ assegno tutti i parametri passati ad un array, e se io volessi passare due array e manipolare prima \@a e fare tot operazioni su di questo e poi trattare \@b e fare altre operazioni...si può eseguire una cosa simile in perl?se si come?

grazie in anticipo

[shishii]

Ho splittato la discussione, poichè completamente fuori tema in relazione al resto.

La prossima volta aprine una nuova tu.

Comunque...

subchiamante(\@a, \@b, \@c);

sub subchiamante {
my $primo = split;
my $secondo = split;
my $terzo = split;

# e per accedere ai vari elementi:

print $primo->[0]; # stampa il primo elemento del primo array

# per fare un ciclo:

foreach my $element (@{$secondo}) {
print $element;
}
}

[ant21]

grazie mille, troppo gentile, non l'ho aperta una nuova per non intasare il forum..

comunque..

per fortuna sono entrato nel forum da google, infatti attendevo la risposta su thunderbird ma la stessa nn sarebbe mai arrivata

ciao ed alla prossima, dovessi avere problemi riposto

[ant21]

Originariamente inviato da ant21
grazie mille, troppo gentile, non l'ho aperta una nuova per non intasare il forum..

comunque..

per fortuna sono entrato nel forum da google, infatti attendevo la risposta su thunderbird ma la stessa nn sarebbe mai arrivata

ciao ed alla prossima, dovessi avere problemi riposto

dimenticavo, nel caso di passaggio di parametri per valore devo utilizzare ugualmente split?

cioè con "split" acquisisco ed associo qualsiasi parametro passato alla mia subrotine chiamata?

anche se vi sono nella chiamata sia parametri referenza che valore?

inoltre, che significato ha nella stampa il "->"? in "print $primo->[0];"

ciao

[shishii]

Scusami... ho scritto una sciocchezza!!

non è "split" ma "shift" la funzione da usare.

Con shift estrai il primo elemento di un array.

Ammettendo che hai:
@array = (1,2,3);
$primo_elemento = shift(@array);
print $primo_elemento;

stampa: 1

I parametri vengono passati alle subroutines tramite un array globale di Perl "@_", per cui per estrarre i parametri si può fare:

sub tuaroutine {
$primo = shift(@_);
# oppure più semplicemente:
$primo = shift;
# essendo @_ implicito
}

l'operatore freccia si usa quando lavori un una variabile che punta una struttura (array o hash) referenziandola, ad esempio:

@array = (1,2,3);
print $array[0];
stampa: 1

$ref = \@array;
print $ref[0]; # sbagliato
print $ref->[0]; # giusto stampa 1

[ant21]

nel caso in cui ho una chiamata del genere

&sub_chiamante(\@a,\@b,@c) --> quindi due per referenza uno valore

nella subroutine chiamata come li gestisco, così..

subchiamata
{
$primoarray = shift;
$secarray = shift;
$terzarray = shift;
}



spero di si...anche se ho letto che "shift" mi pare restituisce il primo elemento dell'array e lo elimina..

nulla togliere al tuo esempio, sembra faccia riferimento ad un solo array..il mio problema è : passare due o più arrays tramite subroutine con qualsiasi tipo di metodo (referenza--valore--nome (se esiste)) e trattare nella subroutine chiamata ogni array singolarmente

grazie e ciao

[LordSaga640]

ciao

questo va bene
subchiamata
{
$primoarray = shift;
$secarray = shift;
$terzarray = shift;
}

equivalente a
subchiamata
{
($primo,$secondo,$terzo)=@_;
}

Ricorda che tutti i parametri che passi sono inseriti nello stesso ordine nel vettore @_ .
shift to toglie il primo elemento dell'array. Se non specifichi un array preciso usa @_ che è quello che contiene gli array nel tuo caso.

subchiamata(\@a,\@b,\@c); #è corretto è ti funziona


In $Primoarray te hai l'indirizzo del primo array. Se te lavori con l'indirizzo vai a modificare il vettore originale.
Dunque se dentro la sub di prima fai
$primoarray->[0]='ciao mondo'; # -> si usano con i puntatori ad hash, array, code, scalari
modifichi il primo elemento del vettore anche nel main.

Se ti trovi male puoi anche fare una copia del vettore.
@copia=@$primoarray; # viene valutata l'espressione nel contesto lista e viene fatta la copia


perl rulez

ciao

[shishii]

Originariamente inviato da ant21
nel caso in cui ho una chiamata del genere

&sub_chiamante(\@a,\@b,@c) --> quindi due per referenza uno valore

nella subroutine chiamata come li gestisco, così..

subchiamata
{
$primoarray = shift;
$secarray = shift;
$terzarray = shift;
}



spero di si...anche se ho letto che "shift" mi pare restituisce il primo elemento dell'array e lo elimina..

nulla togliere al tuo esempio, sembra faccia riferimento ad un solo array..il mio problema è : passare due o più arrays tramite subroutine con qualsiasi tipo di metodo (referenza--valore--nome (se esiste)) e trattare nella subroutine chiamata ogni array singolarmente

grazie e ciao

dimentichi che quello che stai passando è un array di array, per cui se passi:

&sub_chiamante(\@a,\@b,@c);

puoi fare:

sub subchiamata
{
$primoarray = shift;
$secarray = shift;
@terzarray = shift; # il terzo array viene passato come tale
}

tieni presente infatti che all'interno della sub, se non usi lo shift, potresti accedere agli elementi così:

subchiamata
{
print $_[0]->[0]; # accede al primo elemento del primo array
print $_[1]->[0]; # accede al primo elemento del secondo array
print $_[2][0]; # accede al primo elemento del terzo array, nota la differenza, manca ->, in quanto non è referenziato.
}

l'array globale è @_ e ai suoi elementi si accede con $_[indice].

[ant21]

Grazie a tutti per le risposte , ho risolto per il momento trattando l'array nella subroutine chiamata cos' @{$_[0]}->[$indice]...ma lo script continua...

altro problema...

esiste un metodo per poter passare l'array per riferimentoo ad una subrotine, copiarlo in un altro array all'interno della subroutine chiamata e svuotarlo restituendo alla subroutine chiamante un array nuovo in cui è stato copiato il vecchio ed il vecchio vuoto?

ho pensato di utilizzare la funzione shift, ma non riesco ad impostarla sintatticamente..

qualcuno sa aiutarmi?

ringrazio in anticipo per le risposte

[ant21]

ho risolto, l'array sono riuscito a svuotarlo associandogli la lista vuota

@array = ();
undef @array; ,

ora quello che mi tormenta è

se effetto una chiamata ad una subroutine

&chiamata(\@a, $indicearraya , $#a)

e gestico l'array passato alla subroutine così

my ($indice) = $_[1];
my ($n) = $_[2];
my ($array) = @{$_[0]}->[$indice];

nel caso in cui volessi richiamare un altra volta e per tante altre volte questa subroutine, come posso gestire i vari arrays passati di volta in volta?

ho notato che se effettuo una chiamata del genere sembra andare in loop sul primo elemento dell'array

&chiamata(\@b, $indicearrayb , $#b)

dovrei gestirli ogni volta in maniera tale da incrementare l'indice che mi tiene traccia dell'array? nel mio caso è sempre "0",perchè comunque io passao un solo array ad ogni chiamata,

spero dii essermi spiegato al meglio, praticamente voglio effettuare la stessa chiamata in maniera ricorsiva passando sempre un array ma che di volta in volta questo array ha degli elemnti diversi fino a che non si verifica una certa condizione.