Références

Les références permettent de bâtir des structures complexes et composées : tableau de tableaux ou de tables de hachage et inversement, table de hachage de tableaux ou de tables de hachage ...

Le terme de référence en Perl correspond à peu près à celui de pointeur en C et C++ et à celui de référence en Java. Les habitués du C ou C++ noterons que les calculs sur références sont interdits en Perl, ce qui permet d'éviter toutes sortes de problèmes dus à des accès mémoire erronés (plus de Segmentation fault).

Chaque variable, qu'elle soit scalaire, tableau ou table de hachage, est présente à une position donnée dans la mémoire. Une référence vers une variable est (schématiquement) l'adresse mémoire de cette variable. Une telle référence peut elle-même être stockée dans une variable scalaire.

Références sur scalaire

L'opérateur qui permet de prendre la référence d'une variable est l'anti-slash (\) : \$v est la référence de la variable $v

    my $refv  = \$v;

Ici la variable $refv (on aurait pu choisir un tout autre nom pour cette variable) est une référence vers la variable $v. Une variable de type référence, quelque soit celui de la variable qu'elle référence (scalaire, tableau ou table de hachage), est un scalaire. On peut représenter la relation entre ces deux variables de la façon suivante :

La variable $refv contient l'adresse de la variable $v (ainsi que l'information consistant à savoir que $v est une variable scalaire). On dit que $refv pointe vers $v, car on va pouvoir manipuler $v (l'afficher, la modifier etc) en utilisant $refv ; on représente ce lien par une flèche de $refv vers $v.

Il nous est alors possible de manipuler $v au travers de $refv. La notation $$refv (donc avec deux dollars) est équivalente à $v tant que $refv pointe vers $v. Autrement dit, la notation $$refv équivaut à la variable scalaire pointée par la référence $refv. Dit de manière plus prosaïque, on va accéder à la variable qu'il y a "au bout" de la référence (au bout de la flèche du schéma). On dit alors que l'on déréférence la variable $refv. Pour faire un parallèle avec le langage C, il s'agit de l'équivalent de l'étoile (*) appliquée à un pointeur.

Revenons sur notre exemple. Nous déclarons une variable scalaire $v que nous initialisons. Nous déclarons ensuite une autre variable scalaire $refv à laquelle on affecte l'adresse de $v ; $refv est donc une référence sur $v :

    my $v = -43.5;
    my $refv  = \$v;

On affiche la valeur de la référence :

    print "$refv\n";   # affiche SCALAR(0x80ff4f0)

On voit bien alors que la référence pointe vers une variable de type scalaire (SCALAR) dont l'adresse mémoire est affichée en hexadécimal. Affichons maintenant la variable pointée par $refv (c'est-à-dire $v ici) :

    print "$$refv\n";  # affiche -43.5

L'affichage effectué est -43.5 (c'est-à-dire la valeur de $v). Cette notation $$refv est équivalente à $v puisque $refv est une référence sur $v. Cette équivalence vaut aussi bien lorsque l'on a besoin de la valeur de $v (affichage etc) que lorsque l'on veut affecter une nouvelle valeur à $v :

    $$refv = 56;       # affecte 56 à $v

On affecte 56 à $$refv, c'est-à-dire à $v. Si on affiche cette variable, on voit bien qu'elle contient cette nouvelle valeur :

    print "$$refv\n";  # affiche 56
    print "$v\n";      # affiche 56

Rien de bien sorcier.

Utilisation des références sur scalaire

À quoi peut bien servir une référence sur un scalaire ? Par exemple à le modifier dans une fonction :

Références sur tableau

Il est possible de créer une référence sur un tableau. L'opérateur qui permet cela est le même que pour les scalaires ; il s'agit de l'anti-slash (\) appliqué à une variable de type tableau :

    my @t = (23, "ab", -54.4);
    my $reft  = \@t;

La variable scalaire $reft est donc une référence vers le tableau @t :

Pour déréférencer une telle référence, il convient d'utiliser une arobase (@) : @$reft est équivalent à @t. On peut ainsi utiliser la valeur de @t en utilisant $reft :

    my @t2 = @$reft;
    foreach my $e (@$reft) { ... }

On peut aussi modifier @t de la sorte :

    @$reft = (654.7, -9, "bonjour");

Si, pour accéder au ième élément de @t, il était possible d'écrire $t[i], il est maintenant possible d'écrire $$reft[i]. On peut alors dire, de manière schématique et pour fixer les choses, que la notation $reft est équivalente au nom t de la variable dans toute les syntaxes utilisant ce tableau (partout où l'on peut écrire t, on peut écrire $reft à la place, tant que $reft pointe sur @t). Voici, en effet, un récapitulatif des équivalences de notations :

Cette dernière notation $reft->[i] est équivalente à $$reft[i] et correspond donc au ième élément du tableau référencé par $reft. C'est la notation la plus souvent utilisée pour cela ; elle rappelle la même notation flèche (->) du langage C.

L'expression

    $reft->[1] = "coucou";

affecte donc à l'élément d'indice 1 du tableau pointé par $reft une nouvelle valeur.

Munis des références, il va maintenant nous être possible de créer des tableaux de tableaux. Cela était pour le moment impossible en raison de l'aplatissement des listes. Une référence étant un scalaire, il va nous être possible de stocker une référence comme valeur dans un tableau :

    my @t1 = ( 16, -33 );
    my @t2 = ( "el", 0.3, 4 );
    my @t = ( 6, \@t1, \@t2, "s" );

Le tableau @t comporte donc un premier élément valant 6, un deuxième étant une référence vers un tableau à deux éléments, un troisième une référence vers un tableau à trois éléments et enfin un élément valant la chaîne "s".

Ce qui peut se représenter sous la forme suivante :

Vous noterez bien que la syntaxe suivante correspond à la création d'un tableau à sept éléments (aplatissement des listes) :

    my @t2 = ( 6,
               ( 16, -33 ),
               ( "el", 0.3, 4 ),
               "s" );

Nous verrons dans la suite d'autres syntaxes pour construire des tableaux de tableaux.

Références sur table de hachage

De la même façon que pour les scalaires et pour les tableaux, la création d'une référence vers une table de hachage utilise l'opérateur anti-slash (\) :

    my %h = ( 'Paul' => 21,
             'Julie' => 19 );
    my $refh = \%h;

La variable scalaire $refh est donc une référence vers la table de hachage %h :

Pour déréférencer une référence vers une table de hachage, il faut utiliser le caractère pourcentage (%) ; %$refh est équivalent à %h :

    my %h2 = %$refh;
    foreach my $k (keys %$refh) { ... }

Les deux notations suivantes permettent d'accéder à la valeur associée à la clef Paul : $$refh{Paul} et $refh->{Paul} sachant que la seconde est la plus utilisée pour des raisons identiques aux cas des tableaux.

    $refh->{Jacques} = 33;

Voici un récapitulatif des équivalences :

Voici une façon d'afficher tous les couples clef/valeur de la table de hachage référencée par $refh :

    foreach my $k (keys %$refh)
    {
      print "$k $refh->{$k}\n";
    }

Cette notation flèche rend l'expression plutôt lisible.

Réflexions à propos des références

On a vu que pour déréférencer une référence vers un scalaire on utilise le caractère dollar ($), vers un tableau le caractère arobase (@) et vers une table de hachage le caractère pourcentage (%). Mais que se passerait-il s'il nous venait à l'idée de ne pas choisir le bon caractère de déréférencement, par exemple d'utiliser le dollar pour une référence sur tableau ou bien le pourcentage pour une référence sur scalaire ? N'arriverons-nous pas à des incohérences comme en C ?

La réponse est non, car l'interpréteur veille au grain. Il refusera de considérer comme un tableau une variable scalaire par exemple. En cas d'incompatibilité de type, un de ces trois messages sera affiché lors de l'exécution et le programme prendra fin :

    Not a SCALAR reference at script.pl line 23.
    Not an ARRAY reference at script.pl line 23.
    Not a HASH reference at script.pl line 23.

Comme une référence peut pointer vers n'importe quel type de structure (scalaire, tableau, table de hachage), cette vérification ne peut avoir lieu qu'au moment de l'exécution.

De plus, les habitués du langage C seront invités à se mettre une bonne fois pour toute dans la tête :-) qu'il n'y a pas d'arithmétique possible sur les références en Perl. Ajouter 1 à une référence ne correspond pas à pointer vers l'élément d'indice 1 d'un tableau, mais à faire perdre le caractère référence à la variable (elle devient un scalaire comme un autre) :

    my $v = 45;
    my $r = \$v;
    print "$r\n"; # affiche SCALAR(0x80fd4c4)
    $r++;
    print "$r\n"; # affiche 135255237

On voit bien ici que la variable $r perd son caractère spécifique de référence ; elle a toujours pour valeur l'adresse de la variable (ici incrémentée de 1 : 80fd4c4 est la représentation hexadécimale du nombre 135255236), mais n'est plus une référence, il sera donc impossible de la déréférencer.

Notez aussi qu'une référence peut changer de valeur, c'est-à-dire de variable pointée et donc de type de variable pointée :

    my $v = 45;
    my @t = ("ee",-2);
    my $r = \$v;
    $$r = -32;    # modification de $v
    $r = \@t;
    $r->[0] = 28; # modification de $t[0]

Dernière chose importante, si vous passez une référence à une fonction, vous devez bien voir que la copie de la seule référence est effectuée, la structure pointée par la référence ne l'est pas ; vous pourrez donc la modifier dans la fonction :

Références anonymes vers scalaire

Une référence anonyme est une référence vers une variable qui n'a pas de nom. Nous avons déjà vu comment faire cela pour un scalaire avec une fonction (fonction f2 un peu avant), mais cela n'est pas la façon de faire la plus simple.

La syntaxe pour créer directement une référence anonyme vers un scalaire est la suivante : \valeur-constante

    my $ref1 = \34;
    my $ref2 = \"er";
    print "$$ref1 $$ref2\n";

Une telle valeur est une constante, il est impossible de modifier la valeur pointée par la référence (différence avec le mécanisme de la fonction f2) :

    $$ref1 = "hello";
    # Modification of a read-only value attempted at script.pl line 24.

Ce n'est pas dans le cas des scalaires que les références anonymes sont les plus utilisées ; elles le sont bien plus avec les tableaux et les tables de hachage.

Références anonymes vers tableau

Pour créer une référence anonyme vers un tableau, il faut utiliser la notation suivante : [élément1, élément2, élément3, etc] est une référence vers un tableau comportant les éléments en question.

    my $r = [ 34.4, "ac", -71 ];
    my @t = ( 34.4, "ac", -71 );

La variable $r est une référence vers un tableau comportant trois éléments alors que la variable @t est un tableau à trois éléments (cette dernière notation nous est déjà familière) :

On accède aux éléments de cette référence anonyme comme pour une référence normale :

    print "$r->[0]\n";
    $r->[2] = 901;
    foreach my $e (@$r) { ... }

Attention à ne pas écrire \(2,"er",$v) si vous voulez créer une référence vers un tableau, car cette syntaxe fait toute autre chose : elle est en fait équivalente à (\2,\"er",\$v), donc à une liste de références, ce qui est fort différent.

Le structure précédemment décrite par

    my @t1 = ( 16, -33 );
    my @t2 = ( "el", 0.3, 4 );
    my @t = ( 6, \@t1, \@t2, "s" );

peut donc s'écrire de la manière suivante :

    my @t = ( 6,
              [ 16, -33 ],
              [ "el", 0.3, 4 ],
              "s" );

Ce qui peut se représenter toujours sous la forme suivante :

On peut pousser le vice jusqu'à utiliser une référence pour le premier tableau :

    my $r = [ 6,
              [ 16, -33 ],
              [ "el", 0.3, 4 ],
              "s" ];

Comment accéder aux éléments des différentes profondeurs d'une telle construction ? Il suffit de suivre les références ...

    print "$r->[0]\n";       # affiche 6
    # $r->[1] est une référence vers tableau
    print "$r->[1]->[0]\n";  # affiche 16
    print "$r->[1]->[1]\n";  # affiche -33
    # $r->[2] est une référence vers tableau
    print "$r->[2]->[0]\n";  # affiche el
    print "$r->[2]->[1]\n";  # affiche 0.3
    print "$r->[2]->[2]\n";  # affiche 4
    print "$r->[3]\n";       # affiche s

Ce n'est pas si complexe qu'il n'y paraît pour peu que nous ayons un bon schéma sous la main ... Vous noterez que nous faisons usage de l'opérateur flèche (->) plutôt que de la syntaxe double-dollar ($$).

De plus, si $r->[1] est une référence vers tableau, @{$r->[1]} est le tableau en question. On peut donc écrire :

    foreach my $e ( @{$r->[1]} ) { ... }  # Parcourt 16 et -33

Il faut noter qu'en cas de déréférencements successifs, seule la première flèche est nécessaire : $r->[2][1] est équivalent à $r-[2]->[1]>.

Références anonymes vers table de hachage

De la même façon il est possible de créer une référence anonyme vers une table de hachage. La notation {clef1=>valeur1, clef2=>valeur2, etc} est une référence vers une table de hachage comportant les couples clef/valeur en question.

    my $r = { 'Paul' => 21,
             'Julie' => "e" };
    my %h = ( 'Paul' => 21,
             'Julie' => "e" );

La variable $r est une référence vers une table de hachage alors que la variable %h est une table de hachage (notation familière) :

De la même façon qu'avec des tableaux, nous allons mettre sur pied des tables de hachage de tables de hachage :

    my %h1 = ( 'rue' => 'Pasteur',
               'tel' => '06461341' );
    my %h2 = ( 'rue' => 'Jaures',
               'tel' => '03729103' );
    my $r = { 'Paul' => \%h1,
             'Julie' => \%h2 };

Ou plus directement :

    my $r = {
       'Paul' =>
           { 'rue' => 'Pasteur',
             'tel' => '06461341' },
       'Julie' =>
           { 'rue' => 'Jaures',
             'tel' => '03729103' }
            };

Voici comment accéder à tous les éléments d'une telle construction :

    # $r->{Paul} est une référence vers une table de hachage
    print "$r->{Paul}->{tel}\n"; # affiche 06461341
    print "$r->{Paul}{tel}\n";   # équivalent
    print "$r->{Paul}{rue}\n";   # affiche Pasteur
    # $r->{Julie} est une référence vers une table de hachage
    print "$r->{Julie}{tel}\n";  # affiche 03729103
    print "$r->{Julie}{rue}\n";  # affiche Jaures

Il suffit de suivre sur le schéma, d'où l'importance de faire un bon schéma.

Références anonymes diverses

Il est bient-sûr tout à fait possible de mélanger les références vers les tableaux et vers les tables de hachage :

    my $r = [
       ['a',4],
       'b',
       [1,'z'],
       {'P'=>[-2,"er",0],'A'=>7},
       8 ];

Voici le schéma correspondant à cette structure (essayer de vous en convaincre !) :

Voici comment accéder à un élément d'une telle structure :

    print "$r->[3]->{P}->[1]\n"; # affiche "er"
    print "$r->[3]{P}[1]\n";     # équivalent

Les crochets correspondent à une prise d'indice d'un tableau ; les accolades à la clef d'une table de hachage.

Je peux parcourir le premier tableau du deuxième niveau (celui qui comporte a et 4) de la manière suivante :

    my $reft = $r->[0];
    foreach my $v (@$reft)
    {
       print "$v\n";
    }

Je crée une variable $reft qui est une référence vers ce tableau, je peux ensuite parcourir @$reft qui représente le tableau en question.

Il est possible d'écrire cela sans créer de variable temporaire, la syntaxe est la suivante : @{référence} Ces accolades n'ont rien à voir avec les tables de hachage elles permettent juste de délimiter la référence à laquelle on applique l'arobase. Voici ce que cela donne :

    foreach my $v (@{$r->[0]})
    {
       print "$v\n";
    }

On fait de la même façon pour un table de hachage, les accolades délimitent la référence à laquelle on applique le pourcentage :

    foreach my $k (keys %{$r->[3]})
    {
       print "$k $r->[3]{$k}\n";
    }

Commencez-vous à voir l'intéret de faire des schémas ?

L'opérateur ref

La question qui pourrait maintenant venir à l'esprit est la suivante : comment pourrait-on écrire une boucle sur les éléments du tableau référencé par $r et surtout comment savoir de quel type ils sont pour pouvoir les utiliser ? Pour répondre à cette question, voici un nouvel opérateur : ref(). Il permet de connaître le type d'une référence.

Cette fonction renvoie :

• "SCALAR" si son argument est une référence sur scalaire,

• "ARRAY" si son argument est une référence sur tableau,

• "HASH" si son argument est une référence sur table de hachage,

• faux si son argument n'est pas une référence (c'est un scalaire classique).

On peut alors écrire le code suivant :

    foreach my $p (@$r)
    {
       if( ref($p) eq "ARRAY" )
       {
          print "( ";
          foreach my $v (@$p)
          { print "$v "; }
          print ")\n";
       }
       elsif( ref($p) eq "HASH" )
       {
          foreach my $k (keys(%$p))
          { print "$k : $p->{$k}\n"; }
       }
       elsif( !ref($p) )
       {
          print "$p\n";
       }
    }

L'affichage suivant est effectué :

    ( a 4 )
    b
    ( 1 z )
    P : ARRAY(0x8100c20)
    A : 7
    8

Dans cet exemple, un seul premier niveau de références est exploré. Pour aller au-delà, c'est-à-dire, afficher le tableau associé à la clef P, il faudrait concevoir un ensemble de fonctions s'appelant les unes les autres en fonction du type des références rencontrées. Ne vous fatiguez pas à les écrire, il existe déjà une telle fonctionnalité en Perl :

    use Data::Dumper;
    print Dumper($r);

La première ligne ajoute des fonctions à Perl (c'est un peu le #include du langage C) et ne doit donc être présente qu'une seule fois dans le programme (plutôt au début). La seconde consiste en l'affichage de la valeur de retour de la fonction Dumper : cette fonction renvoie une (longue) chaîne de caractères représentant toute la structure référencée par $r :

    $VAR1 = [
              [
                'a',
                4
              ],
              'b',
              [
                1,
                'z'
              ],
              {
                'P' => [
                         -2,
                         'er',
                         0
                       ],
                'A' => 7
              },
              8
            ];

Vous noterez que l'affichage effectué est directement intégrable dans un code Perl.

Références circulaires

La notion de référence circulaire n'a rien de compliqué ; c'est juste le fait que plusieurs tableaux et/ou tables de hachage et/ou scalaires peuvent se référencer entre elles. Par exemple :

On voit bien alors qu'un cycle de références existe entre ces références. Voici comment écrire cela en Perl :

    my $r = [
        71,
        {
          "Hello" => -34.7,
          "Ptt" => { "R5" => "As4" }
        }
      ];
    $r->[1]{Ptt}{Od} = $r;

On comprend bien qu'il n'est pas possible de créer une telle structure en une seule instruction. Comment se comporte Data::Dumper dans une telle situation ? Ne va-t-il pas boucler à l'infini ? Et bien non : il se comporte bien :

    print Dumper($r);
    $VAR1 = [
        71,
        {
          'Ptt' => {
               'R5' => 'As4',
               'Od' => $VAR1
                   },
          'Hello' => '-34.7'
        }
      ];

Data::Dumper se rend compte qu'il passe sur une référence qu'il a déjà parcourue et l'affiche comme telle ($VAR1).

Pourquoi vous parler de références circulaires ? Premièrement parce qu'il faut savoir qu'il est possible d'en faire (cela peut être utile de créer des listes chaînées circulaires etc). Mais surtout parce qu'elles posent des problèmes au garbage-collector dans sa tâche de libération de la mémoire. À la suite à l'exemple précédent, je pourrais écrire :

    $r = undef;

En temps normal, tout ce que $r référençait serait libéré. Mais ici, ce n'est pas le cas. En effet, chacun des tableaux et des tables de hachage ont encore au moins une référence vers elle, le garbage-collector ne se rend pas compte, qu'en fait, les trois objets peuvent être libérés. Nous sommes donc en présence de zones mémoires inaccessibles (aucune variable ne nous permet d'y accéder) et non libérables : cette mémoire est perdue pour le programme ! Elle sera bien sûr libérée quand le programme prendra fin, mais s'il s'agit d'un démon qui tourne en permanence, cette fuite mémoire n'est pas forcément à négliger.

La solution pour éviter cela est de "casser" la circularité avant de modifier la valeur de la variable $r :

    $r->[1] = undef;

Je viens de casser le lien indiqué par un astérisque, il n'y a plus de boucle dans les références. Maintenant et seulement maintenant, je puis sans risque écrire :

    $r = undef;

Et la mémoire sera libérée ...

Références sur fichiers

Une ouverture de fichier crée une variable dont il est possible de prendre l'adresse. Voici la syntaxe pour cela :

    open(FILE,">toto") or die("$!");
    my $reff = \*FILE;

La variable scalaire $reff est une référence vers le descripteur de fichier FILE. Il nous est aussi possible de créer une référence vers un des trois fichiers pré-existant :

    my $refo = \*STDOUT;

Voici des exemples d'utilisation de ces références :

Références sur fonctions

Comme dans le langage C, une fonction a elle-aussi une adresse mémoire. Cette adresse correspond à l'endroit de la mémoire où le code de la fonction est stocké. On peut obtenir une référence vers une fonction de la manière suivante :

Un dernier mot sur les références

De telles structures nous donnent envie de faire de la programmation objet (champs et méthodes pourraient être stockées dans une table de hachage). N'allons pas trop vite car Perl a été prévu pour la programmation objet et propose les fonctionnalités nécessaires (héritage ...) en se basant sur les modules.

L'auteur