% $Id$

\section{Variables bis}

\subsection{Références}

\begin{frame}[fragile]
\frametitle{Référence: Concept}
\begin{block}{Quoi ça ?}
C'est une valeur scalaire\ldots

\pause
\vfill
qui fait référence à un scalaire, un tableau ou un hash.

\pause
\vfill
\begin{itemize}
\item elle contient l'adresse mémoire de l'élément pointé
\pause
\item plusieurs références peuvent pointer la même variable
\pause
\item on peut faire des tableaux de références\ldots
\end{itemize}
\end{block}
\pause
\vfill
\begin{alertblock}{Ce n'est pas un pointeur au sens C du terme}
\verb.$ref++;. ne donnera rien de bien !!!!

On fait du perl, on ne joue pas avec les octets de la mémoire.
\end{alertblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Créer des références}
\begin{exampleblock}{Renvoyer la référence de}
\verb+\+ pour renvoyer un référence:
\begin{verbatim}
my $ref = \$scalaire;
my $ref = \@tableau;
my $ref = \%hash;
\end{verbatim}
\end{exampleblock}
\vfill
\pause

\begin{block}{Créer une référence:}
\begin{tabular}{|l|c|}
\hline
Type de variable&code\\
\hline
\hline
tableau&\verb+[ 'val1', 'val2' ]+\\
\hline
hash&\verb+{ key => val }+\\
\hline
\end{tabular}
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{Utiliser les références}

\begin{exampleblock}{prenons une référence}
\begin{verbatim}
$ref = { key => 'val' }; print $ref;
HASH(0x8bca880)
\end{verbatim}
\end{exampleblock}
\pause

\begin{block}{Accès aux variable}
\center
\begin{tabular}{|l|c|c|}
\hline
type&variables&éléments de\\
\hline
\hline
scalaire&\verb+$$var+&\\
\hline
tableau&\verb+@{$ref}+&\verb+$ref->[0]+\\
\hline
hash&\verb+%{$ref}+&\verb+$ref->{'key'}+\\
\hline
\end{tabular}
\end{block}
\pause

\begin{exampleblock}{}
\begin{verbatim}
foreach my $key (keys %$ref) {
    print "$ref->{$key}\n";
}
\end{verbatim}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Pourquoi les références ?}
\begin{alertblock}{Perl aplati les listes, remember ?}

\pause
\begin{verbatim}
my @tab1 = (1,2); my @tab2 = (3,4);
my @tab = (@tab1, @tab2);
\end{verbatim}
\verb+@tab+ contient 4 éléments...
\end{alertblock}
\pause

\begin{block}{par contre:}
\begin{verbatim}
my @tab1 = (1,2); my @tab2 = (3,4);
my @tab = (\@tab1, \@tab2);
\end{verbatim}
\verb+@tab+ contient 2 éléments qui réferencent des tableaux.
\end{block}
\pause

\begin{block}{On accède aux valeurs:}
\begin{verbatim}
$tab[0]->[0];
$tab[0][0];
\end{verbatim}
\end{block}

\end{frame}

\begin{frame}[fragile]
\frametitle{Références: les pièges}
\begin{alertblock}{Déférencer un undef:}
\begin{verbatim}
perl -we 'my $ref; print @{ $ref }'
Use of uninitialized value $ref in 
array dereference at -e line 1.
\end{verbatim}
\end{alertblock}
\pause
\vfill
\begin{alertblock}{Attention au type de variable référencée:}
\begin{verbatim}
perl -we 'my $ref = {}; print @{ $ref }'
Not an ARRAY reference at -e line 1.
\end{verbatim}
\end{alertblock}
\pause
\vfill
\begin{alertblock}{Attention au structure complexes:}
\begin{verbatim}
$ref->[0][2]{daleks}[0]{episode}
    {$ennemi}{histoire}[0];
\end{verbatim}
\end{alertblock}
\end{frame}

\subsection{les descripteurs de fichier}

\begin{frame}[fragile]
\frametitle{Fichiers: Version simple}
\begin{exampleblock}{Ouvrir un fichier en lecture:}
\begin{verbatim}
open(my $handle, '<', 'fichier');
\end{verbatim}
\end{exampleblock}
\pause
\begin{exampleblock}{Lire une ligne:}
\begin{verbatim}
my $line = <$handle>;
chomp($line); # strip cariage return
\end{verbatim}
\end{exampleblock}
\pause
\begin{exampleblock}{Fermer le fichier:}
\begin{verbatim}
close($handle);
\end{verbatim}
\end{exampleblock}
\pause
\vfill
\begin{alertblock}{Ancienne méthode (perl < 5.6)}
\begin{verbatim}
open(HANDLE, '<', 'fichier');
my $line = <HANDLE>;
close(HANDLE);
\end{verbatim}
\end{alertblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Fichier: version simple (suite)}

\begin{exampleblock}{Ecrire}
\begin{verbatim}
open(my $handle, '>', 'fichier');
print $handle "Exterminate !\n";
close($handle);
\end{verbatim}
\end{exampleblock}
\pause

\begin{alertblock}{Attention à print}
pas de \verb+,+ après le file handle
\end{alertblock}

\pause
\vfill
\begin{block}{File handle par défaut}
\begin{itemize}
\item \verb+STDERR+ (sortie d'erreur)
\item \verb+STDOUT+ (sortie standard)
\item \verb+STDIN+ (entrée standard)
\end{itemize}
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{Fichiers: Version compliquée}
\begin{block}{haut niveau}
\begin{itemize}
\item open()/close()
\item read()/print()
\end{itemize}
\end{block}

\pause
\vfill
\begin{block}{bas niveau}
\begin{itemize}
\item sysopen()/sysclose()
\item sysread()/syswrite()
\end{itemize}
\end{block}

\pause
\vfill
\begin{block}{Glob !}
Pour info, un filehandle est une variable de type \textbf{GLOB}.
\end{block}

\pause
\vfill
\begin{block}{Si vraiment vous voulez en savoir plus: man}
\begin{itemize}
\item perlfunc
\item perlopentut
\end{itemize}
\end{block}
\end{frame}