### Références
- Objectif :
- Construire des structures complexes
- ~ pointeurs en C/C++ et références en Java
### Références
## Références sur les scalaires
### Principe
```
my $v = 10;
my $refv = \$v;
```
### Principe
```
my $v = 10;
my $refv = \$v;
print "$refv\n";
```
```
print "$$refv\n";
```
```
$$refv = 56;
print "$$refv\n";
print "$v\n";
```
Note:
Notebook
### Utilisation
Modification dans une fonction
```
sub f1{
my ($ref) = @_;
$$ref = $$ref + 10;
}
my $v = 20;
my $refv = \$v;
f1( $refv );
print "$v\n";
f1 ( \$v );
print "$v\n";
```
Note:
Notebook
### Utilisation
Renvoi d'une variable par une fonction
```
sub f2{
my $v = 20;
return \$v;
}
my $ref = f2();
print "$$ref\n";
```
Note:
Notebook
## Références sur les tableaux
### Principe
```
my @tab = ("ab",10);
my $reft = \@tab;
```
### Principe
```
my @tab = ("ab",10);
my $reft = \@tab;
```
```
my @tab2 = @$reft;
print "$tab2[1]\n";
print "$$reft[1]\n";
```
```
@$reft = ("bc",11);
print "$tab[0],$tab[1]\n";
```
```
$reft->[1] = 12;
print "$tab[1]\n";
```
Note:
Notebook
### Principe
Tableau | Référence
--- | ---
`tab`| `$reft`
`@tab` | `@$reft`
`$tab[i]` | `$$reft[i]`
`$tab[i]` | `$reft->[i]`
### Tableaux de tableaux
```
my @t1 = ("tutu", 10);
my @t2 = (20, 30);
my @t = (2, \@t2, \@t1, ("et",20));
```
### Référence à un tableau dans une fonction
```
sub f{
my ($reftab) = @_;
$reftab->[2] = 40;
}
my @tab = ( "hello", 10, -2 );
my $ref = \@tab;
f( $ref );
```
## Références sur les tableaux associatifs
### Principe
```
my %hash = ("Jean" => 10, "Jacques" => 70);
my $refh = \%hash;
```
### Principe
```
my %hash = ('Jean' => 10, 'Jacques' => 70);
my $refh = \%hash;
```
```
my %hash2 = %$refh;
print "$hash2{'Jean'}\n";
```
```
print "$$refh{'Jacques'}\n";
print "$refh->{'Jacques'}\n";
```
Note:
Notebook
### Principe
Tableau associatif | Référence
--- | ---
`hash` | `$refh`
`%hash` | `%$refh`
`$hash{Paul}` | `$$refh{Paul}`
`$hash{Paul}` | `$refh->{Paul}`
### Modules
Fichier `Perl` regroupant un ensemble de variables et de
fonctions touchant un à même domaine
~ Bibliothèque, librairie
### Liste des répertoires contenant des modules
```
$ perl -V
Summary of my perl5 (revision 5 version 16 subversion 0) configuration:
...
@INC:
/Users/bbatut/perl5/perlbrew/perls/perl-5.16.0/lib/site_perl/5.16.0/darwin-2level
/Users/bbatut/perl5/perlbrew/perls/perl-5.16.0/lib/site_perl/5.16.0
/Users/bbatut/perl5/perlbrew/perls/perl-5.16.0/lib/5.16.0/darwin-2level
/Users/bbatut/perl5/perlbrew/perls/perl-5.16.0/lib/5.16.0
.
```
Note:
Mettre les modules à utiliser dans un de ces répertoires
## Utilisation d'un module
```
use NomModule;
```
### Documentation
```
$ perldoc File::Copy
NAME
File::Copy - Copy files or filehandles
SYNOPSIS
use File::Copy;
copy("file1","file2") or die "Copy failed: $!";
copy("Copy.pm",\*STDOUT);
move("/dev1/fileA","/dev2/fileB");
use File::Copy "cp";
$n = FileHandle->new("/a/file","r");
cp($n,"x");
```
Note:
Démo dans un terminal
### Utilisation
```
use File::Copy;
copy("files/file1.txt","files/file2.txt") or die "Copy failed: $!";
copy("files/file1.txt",\*STDOUT);
move("files/file2.txt","files/file3.txt");
```
Note:
Notebook
### Où trouver des modules?
[CPAN](http://www.cpan.org/)
### Principe
1 fichier
- Indépendant des scripts qui l'utilise
- Extension : `.pm`
- Dans un des répertoires de la variable `@INC`
### Structure du fichier
```
# --- MonModule.pm ---
package MonModule;
use strict;
use warnings;
sub bonjour {
my ($prenom) = @_;
print "Bonjour $prenom\n";
}
1;
```
### Utilisation du module
```
# --- script.pl ---
#!/usr/bin/perl
use strict;
use warnings;
use MonModule;
MonModule::bonjour( "Paul" );
```
### Variables dans un module
- Accessibles seulement aux fonctions dans le module : `my`
- Accessibles depuis l'extérieur du module : `our`
### Dernière ligne d'un module
```
1;
```
Valeur de chargement du module
Note:
- Indique si le chargement s'est bien passé
- Posible de mettre une autre valeur
### Documentation
```
# --- MonModule.pm ---
=head1 NAME
MonModule.pm - Useful functions
=head1 SYNOPSIS
use MonModule;
bonjour("Paul");
=head1 DESCRIPTION
Blabla blabla
=cut
```
Note:
POD: Plain Old Documentation
### Documentation
```
# --- MonModule.pm (suite) ---
package MonModule;
use strict;
use warnings;
=head1 FUNCTION bonjour
This function prints hello in french
=cut
sub bonjour {
my ($prenom) = @_;
print "Bonjour $prenom\n";
}
1;
```
### Documentation
```
$ perldoc MonModule.pm
NAME
MonModule.pm - Useful functions
SYNOPSIS
use MonModule;
bonjour("Paul");
DESCRIPTION
Blabla blabla
FUNCTION bonjour
This function prints hello in french
```
# Programmation orientée objet
Programmation procédurale
**Quelles sont les fonctions/actions à faire ?**
Programmation orientée objet
**Quelles sont les données du problème ?**
### Principe
### Exemple : `Employe`
Classe
- Propriétés
- Nom
- Date de naissance
- Salaire
- Méthodes
- Récupération des informations
- Augmentation de salaire
### Exemple : `Employe`
Embauche d'un nouvel employé
- Création d'un nouvel objet
- Remplissage des différentes propriétés
### Principe
- Classe = Module
- Objet/Instance = Référence associée à la classe
## Construction d'une classe et des objets
### Création d'un fichier `Employe.pm`
```
# --- fichier Employe.pm ---
package Employe;
use strict;
...
1;
```
### Ecriture du constructeur
- Création d'une référence vers un tableau associatif
- Association de la référence au package (*bless*)
- Remplissage du tableau associatif avec les propriétés
### Constructeur de la classe `Employe`
```
# --- Employe.pm ---
...
# Constructeur
sub new {
my ($class, $nom, $salaire) = @_;
my $this = {};
bless ($this, $class);
$this->{NOM} = $nom;
$this->{SALAIRE} = $salaire;
return $this;
}
...
```
### Création d'objets
```
# --- script.pl ---
#!/usr/bin/perl
use strict;
use warnings;
use Employe;
my $e1 = Employe->new("Jean Dupont", 2000);
my $e2 = Employe->new("Robert Duval", 1500);
```
### Connaissance de la classe
```
my $e1 = Employe->new("Jean Dupont", 2000);
print "$e1\n";
```
```
Employe=HASH(0x7fc802b5e698)
```
Note:
Notebook
### Visualisation d'un objet
```
use Data::Dumper;
print Dumper($e1)."\n";
$VAR1 = bless( {
'SALAIRE' => 2000,
'NOM' => 'Jean Dupont'
}, 'Employe' );
```
Note:
Notebook
### "Copie" d'un objet
```
my $e1_bis = $e1;
print "$e1_bis\n"
```
Note:
Notebook
### Ecriture
```
# --- Employe.pm ---
...
sub recuperation_info{
my ($this) = @_;
return $this->{NOM}." ".$this->{SALAIRE};
}
sub augmentation_salaire {
my ($this, $pourcentage) = @_;
my $p = (100+$pourcentage)/100;
$this->{SALAIRE} = $this->{SALAIRE}*$p;
}
```
### Utilisation
```
# --- script.pl ---
#!/usr/bin/perl
use strict;
use warnings;
use Employe;
my $e1 = Employe->new("Jean Dupont", 2000);
print "$e1->recuperation_info(2)\n";
e1->augmentation_salaire(2);
print "$e1->recuperation_info(2)\n";
```
Note:
Notebook
## Références
- [Guide Perl](http://formation-perl.fr/guide-perl.html)
## [BioPerl](bioperl.html)