[Perl] passer des parametres par reference

 
:lol:

 
ah bon ? :ouch:  
Je savais meme pas.
Ben euh ... c'est vrai qu'il y a deja des differences (subtiles mais c'est comme l'appel des fonctions ;) )pour les fonctions integrees au langage
undef @array;
undef (@array);
push , pop ... etc

 
Par contre je savais pas qu'on pouvait faire aussi $a->($toto) pour une ref de fonction... je pensais que c'était que pour les hash, merci :)

 
D'apres la documentation de www.perldoc.com, effectivement, ca devrait fonctionner comme cela. J'essaierai de nouveau avec mes fameux hash of arrays pour voir ce que ca dit tout ca ...

bon, j'ai encore dit une connerie, et après ???
 
:lol:

C'est généralement ce que je fais ;)
 
Pour Alligator421, attention aussi à ça :
 
my ($toto) = shift;
$toto pointe sur 1er élément de @_
si tu oublies les () :
my $toto = shift;
$toto n'est pas un pointeur ici

 
A subroutine may be called using an explicit & prefix. The & is optional in modern Perl, as are parentheses if the subroutine has been predeclared. The & is not optional when just naming the subroutine, such as when it's used as an argument to defined() or undef(). Nor is it optional when you want to do an indirect subroutine call with a subroutine name or reference using the &$subref() or &{$subref}() constructs, although the $subref->() notation solves that problem. See perlref for more about all that.
 
Subroutines may be called recursively. If a subroutine is called using the & form, the argument list is optional, and if omitted, no @_ array is set up for the subroutine: the @_ array at the time of the call is visible to subroutine instead. This is an efficiency mechanism that new users may wish to avoid.
 
ca vient de  : http://www.perldoc.com/perl5.6.1/pod/perlsub.html

 
Bah faut savoir combien d'arguments on fournit (et dans ton exemple, Perl va gueuler).  
Sinon tu fais :
$hash_href = shift;

 
Bah normalement le pointeur c'est stockable dans une string, c'est le principe des références donc ça devrait marcher ça :
 
sub fonction ()
{
my ($a, $b, $c) = @_;
}
 
&fonction (\$d, \@e, \%f);

le & n'est plus employé avec les dernières releases de Perl, fonction (\$a, \@b, \%c) suffit

 
j'ai deja essaye si je me souviens bien, mais il m'envoie bouler si je recupere pas dans la fonction en mettant (parce que pointeur)
my $ref_variable = ${$_[0]};
my @ref_tableau = @{$_[1]};
my %ref_hash = %{$_[2]};

 
non attends, tu fais pas ca... mais ça :
&fonction (\$a, \@b, \%c);

[jfdsdjhfuetppo]--Message édité par alligator421--[/jfdsdjhfuetppo]

 
Le shift sert enlever le premier élément d'un tableau et le retourner.
Si tu as plusieurs arguments tu peux faire ainsi :
my ($a, $b, $c) = @_;
 
si il n'y a qu'un seul tableau dans le lot, ca va, mais si il y en a 2 par exemple, il ne saura pas quoi faire...
 
Pour le coup des hash, as-tu essaye de faire ca :
my ($hash_ref) = @_;
 
et ensuite tu peux faire ce que tu veux sur le hash (et ca reste toujours une reference, donc pas de copie) ainsi :
$hash_ref->{toto}

[jfdsdjhfuetppo]--Message édité par alligator421--[/jfdsdjhfuetppo]

 
Qu'est_ce que la liste @_ ???
 
C'est juste un @rray ;) qui empile toutes les variables que tu lui transmets pour les utiliser ensuite à l'intérieur de ta fonction.
 
Si tu alimente @_ avec 2 scalaires ($toto, $titi), @_ devient un tableau de 2 éléments scalaires, ici ça roule
 
Si tu alimente @_ avec 2 tableaux (@pouet, @prout), tes deux tableaux n'en font plus qu'un lorsqu'ils sont transmis à ta fonction
 
Si tu alimente @_ avec 1 scalaire + 1 tableau + 1 hash, @_ regroupe encore une fois tous ces éléments dans un seul tableau.
 
Et là, à moins de passer par les pointeurs, ça devient gonflant (mais réalisable) de reconstituer ton tableau et surtout ton hash.
 
Si donc tu alimente @_ avec 2 hash (%hash1, %hash2), @_ prend les clés et les valeurs de tes deux hash et s'en fait une liste, tu perds la notion de tes deux hash
 
Si tu alimente @_ en lui communiquant les adresses mémoire de tes hash (\%hash1, %hash2), tu lui transmet en fait les premiers éléments de chaque hash. Comme ta fonction connait maintenant l'emplacement mémoire du 1er élément d'un hash, elle sait le reconstituer, tu peux donc envoyer autant de hash que tu le désires dans ta fonction.
 
Sachant également que lorsqu'on transmet un hash par référence à une fonction, le hash n'est pas dupliqué en mémoire puisqu'on travaille avec le vrai.
 
Je me souviens avoir traité un gros hash d'environ 120.000 clés et valeurs, j'ai utilisé 3 fonctions qui transformaient les données du hash et je peux te dire qu'au premier essai, je n'avais pas utilisé les pointeurs, je me suis payé un joli "out of memory", j'ai vite compris d'où venait le bin's
 
:)

Je t'assure que si, mon p'tit bonhomme ! :)
Tu peux passer autant de hash que tu veux en paramètres à une fonction, justement en utilisant les références
J'utilise le @_, car ce n'est rien de plus que la liste stockant TOUS les arguments que tu veux passer à ta fonction.
 
Si tu n'utilises pas les références (je préfère dire pointeurs) et que tu passes 2 hash à une fonction like this :
Fonction(%toto, %pouet)
@_ prend tes deux hash dans sa liste et c'est clair que là, tu ne peux pas retrouver tes deux hash et bosser correctement au sein de ta fonction
 
Si maintenant, tu utilises des pointeurs, je t'assure que tu peux balancer autant de hash que tu veux à ta fonction, like this :
Fonction(\%toto, \%pouet, \%tronche)
Il suffit juste dans ta fonction de respecter le contexte de liste dans tes variables recevant les paramètres.
 
Essaie ce petit script :
 
use strict;
my %toto = qw(1 un 2 deux);
my %pouet = qw(3 trois 4 quatre);
my %truc = qw(5 cinq 6 six);
 
Ma_Fonction(\%toto, \%pouet, \%truc);
 
print "cle 1 de toto = $toto{1}\n";
 
sub Ma_Fonction {
    my ($hash1, $hash2, $hash3) = @_;
 
    print "Cle 1 de hash toto = $hash1->{1}\n";
    print "Cle 1 de hash pouet = $hash2->{3}\n";
    print "Cle 1 de hash truc = $hash3->{5}\n";
 
    # je modifie la clé 1 du hash toto
    $hash1->{1} = 'POUETTTT';
}
 
Essaie et tu verras que tu retrouves bien les clés/valeurs de chacun de tes hash associés aux 3 pointeurs que j'utilise dans la fonction, et tu verras itou que tu peux également modifier leur contenu

[jfdsdjhfuetppo]--Message édité par alligator421--[/jfdsdjhfuetppo]

Salut,
 
Bah écoute essaie ça (si j'ai bien compris ce que tu veux faire) :
 
sub fonction
{
  my ($var_ref, $table_ref, $hash_ref) = @_;
  # Ensuite tu peux accéder aux infos comme ceci
  print $$var_ref . "\n"; # pour la string
  print $$table_ref[2] . "\n"; # pour le tableau
  print $hash_ref->{test} . "\n"; # pour le tableau de référence
}