Farid Hajji

Perl: Einführung, Anwendungen, Referenz (2/e) [Support-Site]

Farid Hajji: Perl - Einführung, Anwendungen, Referenz
2., aktualisierte und erweiterte Auflage
Addison-Wesley Longman, ISBN 3-8273-1535-2

Kapitel 13: Referenzen

Inhalt

• Synopsis
• Eigenschaften von Referenzen
• Referenzen
  • Was ist ein Zeiger?
  • Woher kommen Zeiger?
  • Wie sieht ein Zeiger aus?
  • Werteänderung über Zeiger
  • Der Backslash-Adreßoperator
    • Zeiger auf Skalare
    • Zeiger auf Listen
    • Zeiger auf Hashes
    • Zeiger auf Subroutinen
    • Zeiger auf Filehandles
    • Zeiger auf Zeiger
    • Zeiger auf Lvalues
  • Die *foo{THING}-Syntax
  • Verwendungen von Zeigern
    • Dereferenzierung von Zeigern
    • Speicherung in Variablen
    • Nicht ganz so temporäre Variablen
    • Übergabe an Funktionen
    • Identifizierung des Zeigertyps mit ref()
• Dereferenzierung
  • Die Blocknotation
    • Dereferenzierung von skalaren Zeigern
    • Dereferenzierung von Arrays
    • Dereferenzierung von Hashes
    • Dereferenzierung von Funktionszeigern
    • Dereferenzierung von Filehandles
    • Dereferenzierung von Lvalue-Zeigern
    • Dereferenzierung von Zeigern auf Zeiger
  • Der Pfeiloperator
  • Autovivikation
• Anonyme Strukturen
  • Motivation
  • Anonyme Skalare
  • anonyme Listen
  • Anonyme Hashes
  • Anonyme Subroutinen
• Komplexe Datenstrukturen
  • Listen von Listen: Verschachtelung
  • Listen von Hashes: Objektlisten
  • Hashes von Listen: Multihashes
  • Hashes von Hashes: Dünn besetzte Matrizen
  • Heterogene Hashes
  • Selektion mit grep
  • Transformation und Slice-Auswahl mit map
  • Ausgabe komplexer Datenstrukturen mit Data::Dumper
    • Motivation
    • Selbstgemachte Darstellungsfunktion
    • Das Modul Data::Dumper
    • Anzeige komplexer Datenstrukturen im Debugger
  • Persistenz von komplexen Strukturen
  • Ungarische Notation
• Anwendungen
  • Interpolation von Ausdrücken in Strings
  • Bäume und Graphen
    • Binäre Bäume
    • Beliebige Bäume
    • Graphen
  • Objekte und ihre Konstruktoren
    • Echte Objekte und Stashes
    • Closures statt echter Objekte
  • Die Schwartzsche Transformation
  • Mehrdimensionale Slices verschachtelter Listen
    • Einfache Slices
    • Zweidimensionale Slices
  • Speicherung von Multihashes in einer Textdatei
    • Einfache Hashes
    • Multihashes
  • Referenzen als Schlüssel mit Tie::RefHash
  • Rekursives Kopieren verschachtelter Strukturen
    • Oberflächliches Kopieren
    • Tiefes Kopieren
• Symbolische Referenzen
  • Was sind symbolische Referenzen?
  • Probleme bei symbolischen Referenzen
  • Wozu dienen symbolische Referenzen
• Aufgaben

Synopsis

use strict 'refs';           # Verbiete symbolische Referenzen
no  strict 'refs';           # Erlaube symrefs wieder

# Der Backslash-Operator erzeugt benannte Referenzen
\$scalvar, \@array, \%hash, \&function, \*FH, \substr(), \$ptr, \\var
# Die *foo{THING}-Syntax, anstelle des Backslash-Operators
*foo{SCALAR}, *foo{ARRAY}, *foo{HASH}, *foo{CODE}, *foo{IO}, *foo{GLOB}
# Referenzen auf anonyme Strukturen sind auch möglich
$listptr = [ $var1, "hello", @alist ];
$hashptr = { I => 1, II => 2, III => 3, IV => 4, V => 5 };
$funcptr = sub { print "hello, this is an anon. subroutine\n" };

# Dereferenzierung von Zeigern mit der Blocknotation
${$s_ptr} = "new value";      # Verändert, worauf $s_ptr zeigte
push(@{$a_ptr}, @morevalues); # Ergänzt eine Liste
foreach my $key ( keys %{$h_ptr} ) { ... }
${ gimme_a_ptr($something) } = "this is new";  # Ausdrücke okay

# Dereferenzierung von Zeigern mit dem Pfeiloperator
$a_ptr->[42] = "The answer to all questions";
print $h_ptr->{'PHONE'};        # 555-2311
@resultlist = $f_ptr->($arg1, $arg2, $arg3);

# Typ einer Referenz erkennen
$type = ref($ptr); # SCALAR, ARRAY, HASH, CODE, GLOB, REF, LVALUE
                   # oder Name der Klasse des Objekts $ptr
                   # oder falsch, falls $ptr keine Referenz war

# Komplexe Strukturen
@LoL = ( [ $x11,$x12,$x13 ], [ $x21,$x22,$x23 ], [ $x31,$x32,$x33 ] );
$pivot = $LoL[1][1];
$prof->{'NAME'} = $name; $prof->{'PHONE'} = $phone;
use Data::Dumper; print Dumper(\@LoL, \$prof);

# Die Schwartzsche Transformation
@sorted = map  { $_->[0] }               # 4. Extrahieren
          sort { $a->[1] <=> $b->[1] }   # 3. Sortierung
          map  { [ $_, slowfunc($_) ] }  # 2. Werte vorberechnen
          @nonsorted;                    # 1. Was sortiert wird
# Schlüssel können normalerweise keine Referenzen sein
use Tie::RefHash;
tie %h, 'Tie::RefHash' or die "can't tie: $!\n";
$h{ $ptr } = "some value";
$h{ [ "this", "is", "an", "anonymous", "list" ] } = time();
@refs = keys %h;

# Kopieren komplexer Datenstrukturen
@dstLOL = @oldLoL;             # VORSICHT: Shallow Copy
use Storable qw(dclone);
@copyLoL = dclone(\@oldLoL);   # Deep Copy

# Symbolische Referenzen
$var = "some value";  $vname = 'var'; ${$vname} = "other value";
@ary = ( .... );      $vname = 'ary'; push(@{$vname}, "more");
sub fun { ... }; $vname = 'fun'; $vname->(); $SIG{'INT'} = $vname;

# Eine sinnvolle Anwendung symbolischer Referenzen
if ($arg =~ /-D(\w+)=(\w+)/) { ${$1} = $2 }

Beispielprogramme

Ergänzungen

• Seite 518, letzte Zeile: Bedeutung von \my
  Nach

  @myanons = map { \my $anonvar } 0 .. 10;    # my ist wichtig!
  

  enthält @myanons nun elf Referenzen auf skalare Werte. Um darauf zuzugreifen, müssen diese Referenzen erst dereferenziert werden:

  $myanons->[5] = "new value";
  print $myanons->[3];
  

  Das Array enthält also nicht die skalaren Werte selbst, sondern Referenzen darauf. Solange diese Referenzen im Array @myanons weiterleben, bleibt auch der zugehörige Speicherplatz erhalten, da ihre Referenzzähler noch nicht auf 0 gefallen sind.
  my ist hier wesentlich um mehrere Variablen zu erzeugen. my-Variablen haben normalerweise nur Gültigkeit innerhalb des sie umschließenden Blocks, hier innerhalb des map-Ausdrucks. Ihre Adresse wird jedoch mit Hilfe des Adreßoperators \ in \my $anonvar aus dem map-Ausdruck heraus gerettet. Würde my fehlen, z.B. in map { \$anonvar } 0 .. 10, so würde eine globale Variable $anonvar erzeugt, und dann elfmal dieselbe Referenz darauf zurückgeliefert. Das ist nicht das, was wir hier wollten. (1999/11/19, nach einer Frage von Joachim Backes)

Lösungen zu ausgewählten Übungsaufgaben

In Vorbereitung

FAQ

• In 13.3.5, Abschnitt Zeiger auf Filehandles auf Seite 504 stehen folgende Code-Zeilen zur Demo einer Verwendung für opener.pl:

  my $fh = Open("< /etc/group");
  while (<$fh>) { print; }
  close(*{$fh});
  

  Ich hätte aber geschrieben:

  while (<${$fh}>) { print; }
  

  weil doch $fh eine Referenz auf ein Filehandle ist, und im Diamond-Operator das Filehandle selber stehen muß. (2000/11/26), anonymous.
  Ja, das ist eine verständliche Überlegung, die an und für sich auch logisch klingt. Leider ist es so, daß File/Dir-Handles aus historischen Gründen keine richtigen Präfixe wie Skalare, Arrays, Hashes, oder Funktionen haben. Daher ist es nicht so ohne weiteres möglich, einen Zeiger auf einem File/Dir-Handle zu bekommen:

  $fh_ptr = \FH;    # FALSCH, FH ist Bareword, nicht Handle.
  

  Daher wird stattdessen ein Zeiger auf einen Typeglob *FH genommen:

  $tg_ptr = \*FH;
  

  Nun bedeutet ein Typeglob *FH einen generischen Eintrag in der aktuellen Symboltabelle. *FH steht sowohl für $FH, @FH, %FH als auch &FH und, last but not least, dem Filehandle FH.
  Nun haben wir einen Zeiger auf einem Typeglob, nicht auf einem File/Dir-Handle. Diesen Zeiger zu dereferenzieren hätte nur dann Sinn, wenn man gleichzeitig auch den passenden Typ aus dem Typeglob auswählt:
  
  

    $skalar = ${$tg_ptr};
    @array  = @{$tg_ptr};
    %hash   = %{$tg_ptr};
    &{$tg_ptr}($arg1, $arg2);
    open($tg_ptr, "< myfile");
  

  Da nun File/Dir-Handles keinen Präfix haben, ist es nicht möglich

    unbekannter_praefix{$tg_ptr}
    # oder gar
    {$tg_ptr}
  

  zu sagen, um an den Handle zu kommen.
  Daher akzeptieren <>, sowie alle Funktionen, die einen File/Dir-Handle als Parameter erwarten auch einen Zeiger auf Typeglobs (der nicht dereferenziert werden sollte). (2000/11/27)

Errata

Z.Zt. keine Fehler bekannt.

[Prev] [Up] [Next]

[Alte Quelle]