ABSTRACT: perl: referenzen und komplexere datenstrukturen (list of lists,
          etc..) werden kurz vorgestellt.

AUDIENCE: perl beginners
SYSTEM:   any unix
SECTION:  perl
AUTHOR:   mond <fs@mond.at>
COPYRIGHT: GNU Free Documentation Licence http://www.gnu.org/licenses/fdl.txt

  bis jetzt kennen wir folgende perl datenstrukturen: skalare (einfache
  zahlen, strings), arrays und hashes. eine referenz ist jetzt ein perl
  interner verweis (C programmierer werden hier an pointer denken) auf
  beliebige andere datenstrukturen. angenemmoen wir haben ein array mit dem
  namen @array und ein assoziatives array mit dem namen %hash:
  
$aref = \@array;  
$href = \%hash;

  die variable $aref enthaelt jetzt eine referenz auf dieses @array und wir
  koennen mithilfe von $aref auf die felder des arrays zugreifen. detto mit
  $href.

print ${$aref}[3];

  wuerde jetzt z.b. das element 4te element (wir beginnen ja ueblicherweise
  bei 0 zu zaehlen) unseres arrays @array ausgeben. WICHTIG ist es zu
  verstehen dass bei der zuweisung $aref = \@array KEINE kopie angelegt wird
  sondern nur ein verweis. d.h. aendert man z.b. werte mithilfe von $aref so
  aendern sich auch die werte im original array mit.


  ist alerdings schwer zu
  lesen. ueblicherweise verwendet man die elegantere schreibweise:

print $aref->[3];

  das -> erinnert an einen pfeil und verdeutlicht den verweis-character von
  referenzen. ebenswo wuerde z.b.:

$href->{'ort'}='1160 wien';

  in dem hash auf den $href verweist den schluessel 'ort' mit der zuordnung
  '1160 wien' belegen. (die schreibweise ${$href}{'ort'} waere ebenfalls
  zulaessig aber wieder schwer zu lesen.)

  referenzen sind nun selbst skalare und koennen selbst elemente von arrays
  oder hashes sein. wir koennen damit jetzt komplexe datenstrukuren wie
  arrays von arrays von hashes von arrays aufbauen...

$b[0]=$aref;
  
  zum zugriff auf dieses feld koennten wir jetzt z.b. schreiben;

print $b[0]->[3];

  es gibt jedoch die regel wonach man einen -> zwischen zwei subscripts
  weggelassen werden kann. damit kann man das ganze so schreiben:

$b[0][3]="xyz";

  sieht ja schon aus wie ein 2 dimensionales array. aber auch folgendes perl
  programm waere legal:

#!/usr/bin/perl -w
use strict;
my @array=("ah","baeh","buh");
my %hash=( 'ort' => 'wien',
           'alter' => 32,
           'name' => 'franz' );
my $aref=\@array;
my $href=\%hash;
my @b=();
$b[0]=$aref;
$b[1]=$href;
print $b[1]{'name'},"\n";
print $b[0][2],"\n";

  
  um array referenzen bequemer initalisieren zu koennen gibt es folgende
  schreibeweise:

$feldref = ["ah", "baeh", "buh" ];
 
  $feldref ist jetzt eine referenz auf ein array mit drei string elementen.
  (bei einem normalen array haetten wir oben runde klammern verwendet).
  analog koennten wir z.b. 

@a = ( [1, 2, 3],
       [4, 5, 6],
     );

  ein array anlegen dessen elemente refernezen auf wieder arrays sind.
  entspricht damit einer matrix mit 2 zeilen und 3 spalten.

  eine schleife die alle obige elemente ausgibt koennte z.b. so aussehen:

foreach my $zeile (@a) {
  print "neue zeile\n";
  foreach my $spalte (@$zeile) {
    print $spalte, " ";
  }
  print "\n";
}

  anonyme hashes koennen wir mit  {} initalisieren:

$hashref={ 'ort' => 'hinterholz 8', 'name' => 'alfred' };

  dem aufbau komplexer datenstrukturen steht jetzt nichts mehr im wege. die
  manpages perlref, perldsc, perlreftut, perllol haben noch weitere
  beispiele. (so kann man z.b. auch referenzen auf codestuecke haben.. wie
  wir schon gesehen haben machen das z.b. ja auch unsere objekte die wir vom
  DBI modul oder vom CGI modul bekommen) aber das wichtigste sollte soweit
  klar sein.


EXERCISES:

  * schreibe ein perlscript dass das /etc/passwd file einliest und alle
    zeilen als array in einem hash speichert dessen schluessel der username
    ist. erzeuge ein zweites hash dessen schluessel die userid ist und das
    auf die selben array elemente zeigt. 

    teste ob die datenstruktur tatsaechlich so aussieht wie du denkst in dem
    du die werte aus der struktur am ende in einer schleife wieder ausgibst.
 
  * schreibe eine sub funktion die referenzen auf 2 diminsionale arrays
    akzeptiert und das 2 matrizen (oder vektoren falls eine dimension 0 ist)
    multiplizieren kann. als ergebniss soll eine referenz auf ein
    ergebnissarray zurueckgeliefert werden.


REFERENCES:

man perlreftut
man perlref
man perldata
man perldsc
man perllol