.\" Automatically generated by Pod::Man 2.1801 (Pod::Simple 3.07)
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings.  \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote.  \*(C+ will
.\" give a nicer C++.  Capital omega is used to do unbreakable dashes and
.\" therefore won't be available.  \*(C` and \*(C' expand to `' in nroff,
.\" nothing in troff, for use with C<>.
.tr \(*W-
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
.    ds -- \(*W-
.    ds PI pi
.    if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
.    if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\"  diablo 12 pitch
.    ds L" ""
.    ds R" ""
.    ds C` ""
.    ds C' ""
'br\}
.el\{\
.    ds -- \|\(em\|
.    ds PI \(*p
.    ds L" ``
.    ds R" ''
'br\}
.\"
.\" Escape single quotes in literal strings from groff's Unicode transform.
.ie \n(.g .ds Aq \(aq
.el       .ds Aq '
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
.\" entries marked with X<> in POD.  Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.ie \nF \{\
.    de IX
.    tm Index:\\$1\t\\n%\t"\\$2"
..
.    nr % 0
.    rr F
.\}
.el \{\
.    de IX
..
.\}
.\"
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
.\" Fear.  Run.  Save yourself.  No user-serviceable parts.
.    \" fudge factors for nroff and troff
.if n \{\
.    ds #H 0
.    ds #V .8m
.    ds #F .3m
.    ds #[ \f1
.    ds #] \fP
.\}
.if t \{\
.    ds #H ((1u-(\\\\n(.fu%2u))*.13m)
.    ds #V .6m
.    ds #F 0
.    ds #[ \&
.    ds #] \&
.\}
.    \" simple accents for nroff and troff
.if n \{\
.    ds ' \&
.    ds ` \&
.    ds ^ \&
.    ds , \&
.    ds ~ ~
.    ds /
.\}
.if t \{\
.    ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
.    ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
.    ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
.    ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
.    ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
.    ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.\}
.    \" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
.    \" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
.    \" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
.    ds : e
.    ds 8 ss
.    ds o a
.    ds d- d\h'-1'\(ga
.    ds D- D\h'-1'\(hy
.    ds th \o'bp'
.    ds Th \o'LP'
.    ds ae ae
.    ds Ae AE
.\}
.rm #[ #] #H #V #F C
.\" ========================================================================
.\"
.IX Title "PERLBOT 1"
.TH PERLBOT 1 "2009-08-06" "DocFr" "User Contributed Perl Documentation"
.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.if n .ad l
.nh
.SH "NAME/NOM"
.IX Header "NAME/NOM"
perlbot \- Collection de trucs et astuces pour Objets (the \s-1BOT\s0)
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
L'ensemble suivant d'astuces et d'indications a pour intention d'attiser la
curiosite\*' sur des sujets tels que les variables d'instance et les me\*'canismes
des relations entre objets et classes. Le lecteur est encourage\*' a\*` consulter
des manuels approprie\*'s pour toute discussion sur les de\*'finitions et
me\*'thodologies de l'Oriente\*' Objet. Ce document n'a pas pour but d'e\*^tre un cours
sur la programmation oriente\*'e objet ou un guide de\*'taille\*' sur les
caracte\*'ristiques oriente\*'es objet de Perl ni e\*^tre interpre\*'te\*' comme un
manuel. Si vous cherchez des tutoriels, regardez du co\*^te\*' de perlboot,
perltoot et perltooc.
.PP
La devise de Perl reste\ : il existe plus d'une manie\*`re de le faire.
.SH "SE\*'RIE DE CONSEILS OO"
.IX Header "SE'RIE DE CONSEILS OO"
.IP "1." 5
N'essayez pas de contro\*^ler le type de \f(CW$self\fR. Cela ne marchera pas si
la classe est he\*'rite\*'e, lorsque le type de \f(CW$self\fR est valide mais que
son package n'est pas ce dont a\*` quoi vous vous attendez. Voir re\*`gle 5.
.IP "2." 5
Si une syntaxe oriente\*'e objet (\s-1OO\s0) ou objet indirect (\s-1IO\s0) a\*` e\*'te\*'
utilise\*'e, alors l'objet a probablement un type correct, inutile de
devenir paranoi\*:aque pour cela. Perl n'est de toute fac\*,on pas
paranoi\*:aque, lui. Si des utilisateurs de l'objet corrompent la syntaxe
\&\s-1OO\s0 ou \s-1IO\s0, ils savent probablement ce qu'ils font et vous devriez les
laisser faire. Voir re\*`gle 1.
.IP "3." 5
Utilisez la forme a\*` deux arguments de \fIbless()\fR. Laissez une classe
de\*'rive\*'e utiliser votre constructeur. Voir \*(L"HE\*'\s-1RITAGE\s0 D'\s-1UN\s0
\&\s-1CONSTRUCTEUR\s0\*(R".
.IP "4." 5
La classe de\*'rive\*'e peut connai\*^tre certaines choses concernant sa classe de
base imme\*'diate, la classe de base ne peut rien connai\*^tre a\*` propos de la
classe de\*'rive\*'e.
.IP "5." 5
Ne soyez pas impulsifs avec les he\*'ritages. Une relation
X\ d'utilisation\ X, de X\ contenant\ X ou X\ de\*'le\*'gation\ X (du moins, ce genre de
me\*'lange) est souvent plus approprie\*'e. Voir \*(L"\s-1RELATIONS\s0 \s-1ENTRE\s0 \s-1OBJETS\s0\*(R",
\&\*(L"\s-1UTILISATION\s0 \s-1DE\s0 \s-1RELATIONS\s0 \s-1SDBM\s0\*(R", et \*(L"DE\*'LE\*'\s-1GATION\s0\*(R".
.IP "6." 5
L'objet est l'espace de nom. Y faire des packages globaux les rend
accessibles par l'objet. Voila\*` qui e\*'claircit le flou du package
proprie\*'taire des objets. Voir \*(L"\s-1OBJET\s0 \s-1ET\s0 \s-1CONTEXTE\s0 \s-1DE\s0 \s-1CLASSE\s0\*(R".
.IP "7." 5
La syntaxe \s-1IO\s0 est certainement moins complique\*'e mais incline aux ambigui\*:te\*'s
qui peuvent causer des difficulte\*'s a\*` trouver les bogues. Permettez 
l'utilisation de la bonne syntaxe \s-1OO\s0 me\*^me si cela ne vous dit pas trop.
.IP "8." 5
N'utilisez pas la syntaxe d'appel de fonction, sur une me\*'thode. Vous
rencontrerez des difficulte\*'s un de ces jours. Un utilisateur pourrait
de\*'placer cette me\*'thode dans une classe de base et votre code serait
endommage\*'. En plus de cela, vous attiserez la paranoi\*:a de la re\*`gle 2.
.IP "9." 5
Ne pre\*'sumez pas connai\*^tre le package proprie\*'taire d'une me\*'thode. Vous rendrez
difficile pour un utilisateur de remplacer cette me\*'thode.
Voir \*(L"PRE\*'\s-1VOIR\s0 \s-1LA\s0 RE\*'\s-1UTILISATION\s0 \s-1DU\s0 \s-1CODE\s0\*(R".
.SH "VARIABLES D'INSTANCE"
.IX Header "VARIABLES D'INSTANCE"
Un tableau anonyme ou une table de hachage anonyme peuvent e\*^tre utilise\*'s
pour conserver des variables d'instance. Des parame\*`tres nomme\*'s sont
e\*'galement explique\*'s.
.PP
.Vb 1
\&        package Foo;
\&
\&        sub new {
\&                my $type = shift;
\&                my %params = @_;
\&                my $self = {};
\&                $self\->{\*(AqHigh\*(Aq} = $params{\*(AqHigh\*(Aq};
\&                $self\->{\*(AqLow\*(Aq}  = $params{\*(AqLow\*(Aq};
\&                bless $self, $type;
\&        }
\&
\&        package Bar;
\&
\&        sub new {
\&                my $type = shift;
\&                my %params = @_;
\&                my $self = [];
\&                $self\->[0] = $params{\*(AqLeft\*(Aq};
\&                $self\->[1] = $params{\*(AqRight\*(Aq};
\&                bless $self, $type;
\&        }
\&
\&        package main;
\&
\&        $a = Foo\->new( \*(AqHigh\*(Aq => 42, \*(AqLow\*(Aq => 11 );
\&        print "High=$a\->{\*(AqHigh\*(Aq}\en";
\&        print "Low=$a\->{\*(AqLow\*(Aq}\en";
\&
\&        $b = Bar\->new( \*(AqLeft\*(Aq => 78, \*(AqRight\*(Aq => 40 );
\&        print "Left=$b\->[0]\en";
\&        print "Right=$b\->[1]\en";
.Ve
.SH "VARIABLES D'INSTANCE SCALAIRES"
.IX Header "VARIABLES D'INSTANCE SCALAIRES"
Une variable scalaire anonyme peut e\*^tre utilise\*'e quand seulement une variable
d'instance est ne\*'cessaire.
.PP
.Vb 1
\&        package Foo;
\&
\&        sub new {
\&                my $type = shift;
\&                my $self;
\&                $self = shift;
\&                bless \e$self, $type;
\&        }
\&
\&        package main;
\&
\&        $a = Foo\->new( 42 );
\&        print "a=$$a\en";
.Ve
.SH "HE\*'RITAGE DE VARIABLES D'INSTANCE"
.IX Header "HE'RITAGE DE VARIABLES D'INSTANCE"
Cet exemple illustre comment on peut he\*'riter des variables d'instance
a\*` partir d'une classe de base afin de permettre l'inclusion dans une
nouvelle classe. Ceci ne\*'cessite l'appel du constructeur d'une classe
de base et l'addition d'une variable au nouvel objet.
.PP
.Vb 1
\&        package Bar;
\&
\&        sub new {
\&                my $type = shift;
\&                my $self = {};
\&                $self\->{\*(Aqbuz\*(Aq} = 42;
\&                bless $self, $type;
\&        }
\&
\&        package Foo;
\&        @ISA = qw( Bar );
\&
\&        sub new {
\&                my $type = shift;
\&                my $self = Bar\->new;
\&                $self\->{\*(Aqbiz\*(Aq} = 11;
\&                bless $self, $type;
\&        }
\&
\&        package main;
\&
\&        $a = Foo\->new;
\&        print "buz = ", $a\->{\*(Aqbuz\*(Aq}, "\en";
\&        print "biz = ", $a\->{\*(Aqbiz\*(Aq}, "\en";
.Ve
.SH "RELATIONS ENTRE OBJETS"
.IX Header "RELATIONS ENTRE OBJETS"
Ce qui suit illustre comment on peut mettre en effet les relations de
X\ contenant\ X et X\ d'utilisation\ X entre objets.
.PP
.Vb 1
\&        package Bar;
\&
\&        sub new {
\&                my $type = shift;
\&                my $self = {};
\&                $self\->{\*(Aqbuz\*(Aq} = 42;
\&                bless $self, $type;
\&        }
\&
\&        package Foo;
\&
\&        sub new {
\&                my $type = shift;
\&                my $self = {};
\&                $self\->{\*(AqBar\*(Aq} = Bar\->new;
\&                $self\->{\*(Aqbiz\*(Aq} = 11;
\&                bless $self, $type;
\&        }
\&
\&        package main;
\&
\&        $a = Foo\->new;
\&        print "buz = ", $a\->{\*(AqBar\*(Aq}\->{\*(Aqbuz\*(Aq}, "\en";
\&        print "biz = ", $a\->{\*(Aqbiz\*(Aq}, "\en";
.Ve
.SH "REMPLACER DES ME\*'THODES DE CLASSES DE BASE"
.IX Header "REMPLACER DES ME'THODES DE CLASSES DE BASE"
L'exemple suivant illustre comment remplacer une me\*'thode de classe
de base puis appeler la me\*'thode contourne\*'e. La \fB\s-1SUPER\s0\fR pseudo-classe
permet au programmeur d'appeler une classe contourne\*'e sans connai\*^tre vraiment
ou\*` cette me\*'thode est de\*'finie.
.PP
.Vb 2
\&        package Buz;
\&        sub goo { print "here\*(Aqs the goo\en" }
\&
\&        package Bar; @ISA = qw( Buz );
\&        sub google { print "google here\en" }
\&
\&        package Baz;
\&        sub mumble { print "mumbling\en" }
\&
\&        package Foo;
\&        @ISA = qw( Bar Baz );
\&
\&        sub new {
\&                my $type = shift;
\&                bless [], $type;
\&        }
\&        sub grr { print "grumble\en" }
\&        sub goo {
\&                my $self = shift;
\&                $self\->SUPER::goo();
\&        }
\&        sub mumble {
\&                my $self = shift;
\&                $self\->SUPER::mumble();
\&        }
\&        sub google {
\&                my $self = shift;
\&                $self\->SUPER::google();
\&        }
\&
\&        package main;
\&
\&        $foo = Foo\->new;
\&        $foo\->mumble;
\&        $foo\->grr;
\&        $foo\->goo;
\&        $foo\->google;
.Ve
.PP
Notez bien que \f(CW\*(C`SUPER\*(C'\fR fait re\*'fe\*'rence aux superclasses du paquetage courant
(\f(CW\*(C`FOO\*(C'\fR) et non aux superclasses de \f(CW$self\fR.
.SH "UTILISATION DE RELATIONS SDBM"
.IX Header "UTILISATION DE RELATIONS SDBM"
Cet exemple de\*'crit une interface pour la classe \s-1SDBM\s0. Ceci cre\*'e une
relation X\ d'utilisation\ X entre la classe \s-1SDBM\s0 et la nouvelle classe Mydbm.
.PP
.Vb 1
\&        package Mydbm;
\&
\&        require SDBM_File;
\&        require Tie::Hash;
\&        @ISA = qw( Tie::Hash );
\&
\&        sub TIEHASH {
\&            my $type = shift;
\&            my $ref  = SDBM_File\->new(@_);
\&            bless {\*(Aqdbm\*(Aq => $ref}, $type;
\&        }
\&        sub FETCH {
\&            my $self = shift;
\&            my $ref  = $self\->{\*(Aqdbm\*(Aq};
\&            $ref\->FETCH(@_);
\&        }
\&        sub STORE {
\&            my $self = shift;
\&            if (defined $_[0]){
\&                my $ref = $self\->{\*(Aqdbm\*(Aq};
\&                $ref\->STORE(@_);
\&            } else {
\&                die "Cannot STORE an undefined key in Mydbm\en";
\&            }
\&        }
\&
\&        package main;
\&        use Fcntl qw( O_RDWR O_CREAT );
\&
\&        tie %foo, "Mydbm", "Sdbm", O_RDWR|O_CREAT, 0640;
\&        $foo{\*(Aqbar\*(Aq} = 123;
\&        print "foo\-bar = $foo{\*(Aqbar\*(Aq}\en";
\&
\&        tie %bar, "Mydbm", "Sdbm2", O_RDWR|O_CREAT, 0640;
\&        $bar{\*(AqCathy\*(Aq} = 456;
\&        print "bar\-Cathy = $bar{\*(AqCathy\*(Aq}\en";
.Ve
.SH "PRE\*'VOIR LA RE\*'UTILISATION DU CODE"
.IX Header "PRE'VOIR LA RE'UTILISATION DU CODE"
L'avantage des langages \s-1OO\s0 est la facilite\*' avec laquelle l'ancien code
peut utiliser le nouveau code. L'exemple suivant illustre d'abord comment
on peut empe\*^cher la re\*'utilisation d'un code puis comment promouvoir la
re\*'utilisation du code.
.PP
Le premier exemple illustre une classe qui utilise un appel avec une
syntaxe comple\*`te, d'une me\*'thode afin d'acce\*'der a\*` la me\*'thode prive\*'e
\&\s-1\fIBAZ\s0()\fR. Le second exemple de\*'montrera qu'il est impossible de remplacer
la me\*'thode \s-1\fIBAZ\s0()\fR.
.PP
.Vb 1
\&        package FOO;
\&
\&        sub new {
\&                my $type = shift;
\&                bless {}, $type;
\&        }
\&        sub bar {
\&                my $self = shift;
\&                $self\->FOO::private::BAZ;
\&        }
\&
\&        package FOO::private;
\&
\&        sub BAZ {
\&                print "in BAZ\en";
\&        }
\&
\&        package main;
\&
\&        $a = FOO\->new;
\&        $a\->bar;
.Ve
.PP
A\*` pre\*'sent nous essayons de remplacer la me\*'thode \s-1\fIBAZ\s0()\fR. Nous souhaiterions que
\&\fIFOO::bar()\fR appelle \s-1\fIGOOP::BAZ\s0()\fR, mais ceci ne peut pas se faire car \fIFOO::bar()\fR
appelle explicitement \fIFOO::private::BAZ()\fR.
.PP
.Vb 1
\&        package FOO;
\&
\&        sub new {
\&                my $type = shift;
\&                bless {}, $type;
\&        }
\&        sub bar {
\&                my $self = shift;
\&                $self\->FOO::private::BAZ;
\&        }
\&
\&        package FOO::private;
\&
\&        sub BAZ {
\&                print "in BAZ\en";
\&        }
\&
\&        package GOOP;
\&        @ISA = qw( FOO );
\&        sub new {
\&                my $type = shift;
\&                bless {}, $type;
\&        }
\&
\&        sub BAZ {
\&                print "in GOOP::BAZ\en";
\&        }
\&
\&        package main;
\&
\&        $a = GOOP\->new;
\&        $a\->bar;
.Ve
.PP
Afin de cre\*'er un code re\*'utilisable, nous devons modifier la classe \s-1FOO\s0,
en e\*'crasant la classe FOO::private. L'exemple suivant pre\*'sente une classe \s-1FOO\s0
re\*'utilisable qui permet a\*` la me\*'thode \s-1\fIGOOP::BAZ\s0()\fR d'e\*^tre utilise\*'e a\*` la place
de \s-1\fIFOO::BAZ\s0()\fR.
.PP
.Vb 1
\&        package FOO;
\&
\&        sub new {
\&                my $type = shift;
\&                bless {}, $type;
\&        }
\&        sub bar {
\&                my $self = shift;
\&                $self\->BAZ;
\&        }
\&
\&        sub BAZ {
\&                print "in BAZ\en";
\&        }
\&
\&        package GOOP;
\&        @ISA = qw( FOO );
\&
\&        sub new {
\&                my $type = shift;
\&                bless {}, $type;
\&        }
\&        sub BAZ {
\&                print "in GOOP::BAZ\en";
\&        }
\&
\&        package main;
\&
\&        $a = GOOP\->new;
\&        $a\->bar;
.Ve
.SH "OBJET ET CONTEXTE DE CLASSE"
.IX Header "OBJET ET CONTEXTE DE CLASSE"
Utilisez l'objet afin de re\*'soudre les proble\*`mes de package et de
contexte de classe. Tout ce dont une me\*'thode a besoin doit e\*^tre
disponible par le biais de l'objet ou e\*^tre transmis comme parame\*`tre a\*`
la me\*'thode.
.PP
Une classe aura parfois des donne\*'es statiques ou globales qui devront
e\*^tre utilise\*'es par les me\*'thodes. Une classe de\*'rive\*'e peut vouloir
remplacer ces donne\*'es par de nouvelles. Lorsque ceci arrive, la classe
de base peut ne pas savoir comment trouver la nouvelle copie de la
donne\*'e.
.PP
Ce proble\*`me peut e\*^tre re\*'solu en utilisant l'objet pour de\*'finir le
contexte de la me\*'thode. Laissez la me\*'thode chercher dans l'objet afin
de trouver une re\*'fe\*'rence a\*` la donne\*'e. L'autre alternative est
d'obliger la me\*'thode d'aller a\*` la chasse a\*` la donne\*'e (X\ est-ce dans ma
classe ou dans une classe de\*'rive\*'e\ ? Quelle classe de\*'rive\*'e\ ?\ X), mais ceci peut
e\*^tre ge\*^nant et facilitera le piratage. Il est pre\*'fe\*'rable de laisser
l'objet indiquer a\*` la me\*'thode ou\*` la donne\*'e est situe\*'e.
.PP
.Vb 1
\&        package Bar;
\&
\&        %fizzle = ( \*(AqPassword\*(Aq => \*(AqXYZZY\*(Aq );
\&
\&        sub new {
\&                my $type = shift;
\&                my $self = {};
\&                $self\->{\*(Aqfizzle\*(Aq} = \e%fizzle;
\&                bless $self, $type;
\&        }
\&
\&        sub enter {
\&                my $self = shift;
\&
\&                # Ne cherchez pas a\*` deviner si on devrait utiliser %Bar::fizzle
\&                # ou %Foo::fizzle.  L\*(Aqobjet sait de\*'ja\*` lequel
\&                # on doit utiliser, donc il n\*(Aqy a qu\*(Aqa\*` demander.
\&                #
\&                my $fizzle = $self\->{\*(Aqfizzle\*(Aq};
\&
\&                print "The word is ", $fizzle\->{\*(AqPassword\*(Aq}, "\en";
\&        }
\&
\&        package Foo;
\&        @ISA = qw( Bar );
\&
\&        %fizzle = ( \*(AqPassword\*(Aq => \*(AqRumple\*(Aq );
\&
\&        sub new {
\&                my $type = shift;
\&                my $self = Bar\->new;
\&                $self\->{\*(Aqfizzle\*(Aq} = \e%fizzle;
\&                bless $self, $type;
\&        }
\&
\&        package main;
\&
\&        $a = Bar\->new;
\&        $b = Foo\->new;
\&        $a\->enter;
\&        $b\->enter;
.Ve
.SH "HE\*'RITAGE D'UN CONSTRUCTEUR"
.IX Header "HE'RITAGE D'UN CONSTRUCTEUR"
Un constructeur he\*'ritable doit utiliser le deuxie\*`me forme de \fIbless()\fR
qui permet de lier directement dans une classe spe\*'cifique. Notez dans
cet exemple que l'objet sera un \s-1BAR\s0 et non un \s-1FOO\s0 bien que le
constructeur soit dans la classe \s-1FOO\s0.
.PP
.Vb 1
\&        package FOO;
\&
\&        sub new {
\&                my $type = shift;
\&                my $self = {};
\&                bless $self, $type;
\&        }
\&
\&        sub baz {
\&                print "in FOO::baz()\en";
\&        }
\&
\&        package BAR;
\&        @ISA = qw(FOO);
\&
\&        sub baz {
\&                print "in BAR::baz()\en";
\&        }
\&
\&        package main;
\&
\&        $a = BAR\->new;
\&        $a\->baz;
.Ve
.SH "DE\*'LE\*'GATION"
.IX Header "DE'LE'GATION"
Quelques classes, comme SDBM_File, ne peuvent pas e\*^tre sous\-classe\*'es
correctement car elles cre\*'ent des objects externes. Ce genre de classe
peut e\*^tre prolonge\*'e avec quelques techniques comme la relation X\ d'utilisation\ X
mentionne\*'e plus haut ou par de\*'le\*'gation.
.PP
L'exemple suivant illustre une de\*'le\*'gation utilisant une fonction \s-1\fIAUTOLOAD\s0()\fR
afin d'accomplir un renvoi de message. Ceci permettra a\*` l'object Mydbm
de se conduire exactement comme un objet SDBM_File.
.PP
.Vb 1
\&        package Mydbm;
\&
\&        require SDBM_File;
\&        require Tie::Hash;
\&        @ISA = qw(Tie::Hash);
\&
\&        sub TIEHASH {
\&                my $type = shift;
\&                my $ref = SDBM_File\->new(@_);
\&                bless {\*(Aqdelegate\*(Aq => $ref};
\&        }
\&
\&        sub AUTOLOAD {
\&                my $self = shift;
\&
\&                # L\*(Aqinterpre\*'teur Perl place le nom
\&                # du message dans une variable appele\*'e $AUTOLOAD.
\&
\&                # Un message de DESTRUCTION (DESTROY) ne doit jamais e\*^tre exporte\*'.
\&                return if $AUTOLOAD =~ /::DESTROY$/;
\&
\&                # Enle\*`ve le nom du package.
\&                $AUTOLOAD =~ s/^Mydbm:://;
\&
\&                # Passe le message au de\*'le\*'gue\*'.
\&                $self\->{\*(Aqdelegate\*(Aq}\->$AUTOLOAD(@_);
\&        }
\&
\&        package main;
\&        use Fcntl qw( O_RDWR O_CREAT );
\&
\&        tie %foo, "Mydbm", "adbm", O_RDWR|O_CREAT, 0640;
\&        $foo{\*(Aqbar\*(Aq} = 123;
\&        print "foo\-bar = $foo{\*(Aqbar\*(Aq}\en";
.Ve
.SH "VOIR AUSSI"
.IX Header "VOIR AUSSI"
.Vb 1
\& L<perlboot>, L<perltoot> et L<perltooc>.
.Ve
.SH "TRADUCTION"
.IX Header "TRADUCTION"
.SS "Version"
.IX Subsection "Version"
Cette traduction franc\*,aise correspond a\*` la version anglaise distribue\*'e avec
perl 5.10.0.  Pour en savoir plus concernant ces traductions, consultez
<http://perl.enstimac.fr/>.
.SS "Traducteurs"
.IX Subsection "Traducteurs"
Se\*'bastien Joncheray <info@perl\-gratuit.com>. Mis a\*` jour Paul Gaborit
(Paul.Gaborit @ enstimac.fr).
.SS "Relecture"
.IX Subsection "Relecture"
Simon Washbrook <swashbrook@compuserve.com>