7. Les références

7.1 Description

La référence Perl peut être vue comme le pointeur du langage C. C'est une variable qui en référence une autre. Pour annoter la référence sur la variable scalaire contenant la valeur 1, nous écrirons:

        $i = 1;                   # i est une var. scalaire et vaut 1
        $scalar_ref = \$i;  # scalar_ref référence i.

Pour accéder au contenu pointé par la référence, il faut la déréférencer. Perl utilise l'opérateur -> pour déréférencer une référence.

Pour accéder à la valeur de la variable pointée il faut aussi la déréférencer. De même qu'avec le langage C, une référence peut pointer une autre référence et ainsi de suite. Il faudra donc déréférencer autant de fois que nécéssaire pour obtenir la valeur.

Le valeur pointée peut être modifiée en manipulant la référence.

        int i = 3; int *ref_i = &i; *(ref_i) ++;

        printf("i = %d\n", i);

        $i = 3;
        $ref_i = \$i;
        $ref_i ++;
        print $i, "\n";

7.2 Référence sur un tableau

La référence d'une table peut être créée de plusieurs façons:

        @tab = (1, 2, 3);
        $ref = \@tab;

ou

        $ref = [1, 2, 3];

Pour déréférencer la table, il faut la préfixer du caractère qui désigne la table en Perl : @

        @tab1 = @$ref;

Pour parcourir les éléments de la table on peut écrire:

        foreach (@$ref)
        {
                # $_ contient successivement 1, 2 et 3
        }

On peut directement accéder à un élément contenu dans la table pointée.

        $ref->[0];      # vaut 1
        $ref->[1];      # vaut 2

Pour obtenir le nombre d'éléments pointés :

        $#{@$ref};
         | -----
         |   |
         |    retourne la table et non une référence
         |    (1, 2, 3)
         |
         |
         permet d'obtenir le nombre d'éléments d'une table.

L'expression précédente est équivalente à:

        $#(1, 2, 3);

7.3 Référence sur une table de hash

De même qu'avec la table il existe divers moyens de créer une référence sur une table de hash.

        %hash = (
                'un' => 1,
                'deux' => 2,
                'trois' => 3,
                );

        $ref = \%hash;

ou

        $ref = {
                'un' => 1,
                'deux' => 2,
                'trois' => 3,
                };

Pour déréférencer la référence il faut utiliser le caractère qui désigne la table de hash : %.

        %hash = %$ref;

Le parcours d'une telle référence peut se faire de la manière suivante:

        foreach $k (sort keys %$ref)
        {
                # $k vaut 'deux', 'trois' puis 'un'
        }

        foreach $v (sort values %$ref)
        {
                # $v vaut 1, 2 et 3
        }

On peut modifier un élément pointé comme ceci:

        $ref->{'un'} = 'UN';

On peut étendre une table de hash référencée.

        $ref->{'quatre'} = 100;

On peut effacer un élément référencé:

        delete $ref->{'un'};

7.4 Référence sur une fonction

Cette particularité est appréciable car elle permet entre autres de faire de manière très simple de la génération de code dynamique.

Une référence sur une fonction s'écrit:

        $func = sub { 
                        # code de la fonction
                    };

Pour utiliser la fonction il faut la préfixer du caractère qui désigne (historiquement) la fonction : \&.

        &$func();   # lance la fonction

7.5 Extension: structure de données complexes

Le référencement/déréférencement permet à Perl de pouvoir créer des structures de données complexes.

        $a = [1, 2, 3];

        $b = [
                $a,
                {
                        'un'=>1,
                        'deux'=>2,
                },
             ];

$a référence la table (1, 2, 3). $b est une référence sur une table qui contient deux éléments: $a et une référence sur une table de hash ('un', 1, 'deux', 2).

        $b->[0];                # vaut $a
        @{$b->[0]};             # vaut (1, 2, 3)
        ${@{$b->[0]}}[0];       # vaut 1
        $b->[0]->[0];           # idem

        $b->[1];                # une référence sur une table de hash
        $b->[1]->{'un'};        # vaut 1
        sort keys %{$b->[1]};   # vaut ('deux', 'un')

On imagine très bien les immenses possibilités d'un tel mécanisme. C'est d'ailleurs par ce biais que Perl permet de faire de la programmation orientée objet.