1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
<title>SELFHTML: Perl / Perl-Sprachelemente / Referenzen bzw. Zeiger (Variablen)</title>
<link rel="stylesheet" type="text/css" href="../../src/selfhtml.css">
<meta name="description" content="Was Referenzen bzw. Zeiger in Perl sind, wie sie deklariert werden und wie sie sich verwenden lassen.">
<meta name="keywords" content="SELFHTML, Perl, Referenzen, Zeiger">
<meta name="author" content="Redaktion SELFHTML, selfhtml81@selfhtml.org">
<meta name="robots" content="noindex, nofollow">
<meta name="DC.Publisher" content="SELFHTML e. V.">
<meta name="DC.Date" content="2005-11-09T00:29:27+01:00">
<meta name="DC.Identifier" content="http://de.selfhtml.org/perl/sprache/referenzen.htm">
<meta name="DC.Language" content="de">
<meta name="DC.Rights" content="../../editorial/copyright.htm">
<meta name="DC.Date.created" content="2001-10-27T08:00+01:00">
<meta name="SELF.Pagetype" content="page">
<link rel="alternate" type="application/atom+xml" title="SELFHTML-Weblog (Atom, gesamt)" href="http://aktuell.de.selfhtml.org/weblog/atom-feed">
<link rel="alternate" type="application/rss+xml" title="SELFHTML-Weblog (RSS, Auszge)" href="http://aktuell.de.selfhtml.org/weblog/rss-feed">
<link rel="shortcut icon" type="image/x-icon" href="../../src/favicon.ico">
<link rel="author" title="Impressum" href="../../editorial/impressum.htm">
<link rel="contents" title="Inhaltsverzeichnis" href="../../navigation/inhalt.htm">
<link rel="index" title="Stichwortverzeichnis" href="../../navigation/stichwort.htm">
<link rel="search" title="Suche" href="../../navigation/suche/index.htm">
<link rel="help" title="Hilfe" href="../../editorial/index.htm">
<link rel="copyright" title="Urheberrecht" href="../../editorial/copyright.htm">
<link rel="top" title="SELFHTML" href="../../index.htm">
<link rel="up" title="Perl-Sprachelemente" href="index.htm">
<link rel="next" title="Vordefinierte Variablen in Perl" href="vordefiniert.htm">
<link rel="prev" title="Hashes (Variablen)" href="hashes.htm">
<link rel="first" title="CGI-notwendige Anweisungen in Perl" href="cginotwendig.htm">
<link rel="last" title="CGI-typische Aufgaben in Perl" href="cgitypisch.htm">
</head>
<body>
<table cellpadding="4" cellspacing="0" border="0" width="100%">
<tr>
<td colspan="2" class="nav"><a class="an" name="top"><img src="../../src/refkap.gif" width="16" height="13" alt="Teil von"></a> <a href="../../index.htm">SELFHTML</a>/<a href="../../navigation/index.htm" target="_parent" class="navh">Navigationshilfen</a> <img src="../../src/refkap.gif" width="16" height="13" alt="Teil von"> <a href="../index.htm">Perl</a> <img src="../../src/refkap.gif" width="16" height="13" alt="Teil von"> <a href="index.htm">Perl-Sprachelemente</a></td>
</tr>
<tr>
<td class="doc" width="110"><a href="../../index.htm"><img src="../../src/logo.gif" width="106" height="109" border="0" alt="SELFHTML"></a></td>
<td class="docbot" width="100%"><h1 class="ph1">Referenzen bzw. Zeiger (Variablen)</h1></td>
</tr>
<tr>
<td class="doctop">
<img src="../../src/dokx.gif" width="30" height="20" vspace="6" alt="Informationsseite">
</td>
<td valign="top" nowrap="nowrap">
<p>
<img src="../../src/down.gif" width="14" height="10" alt="nach unten"> <a href="#allgemeines">Allgemeines zu Referenzen in Perl</a><br>
<img src="../../src/down.gif" width="14" height="10" alt="nach unten"> <a href="#auf_skalare">Referenzen auf Skalare</a><br>
<img src="../../src/down.gif" width="14" height="10" alt="nach unten"> <a href="#auf_arrays">Referenzen auf Arrays</a><br>
<img src="../../src/down.gif" width="14" height="10" alt="nach unten"> <a href="#auf_hashes">Referenzen auf Hashes</a><br>
<img src="../../src/down.gif" width="14" height="10" alt="nach unten"> <a href="#auf_subroutinen">Referenzen auf Subroutinen</a><br>
<img src="../../src/down.gif" width="14" height="10" alt="nach unten"> <a href="#auf_dateihandles">Referenzen auf Dateihandles</a><br>
<img src="../../src/down.gif" width="14" height="10" alt="nach unten"> <a href="#auf_referenzen">Referenzen auf Referenzen</a><br>
</p>
</td>
</tr><tr><td colspan="2" class="doc"> <a href="#bottom"><img src="../../src/down.gif" width="14" height="10" border="0" alt="nach unten"></a> </td></tr>
</table>
<h2><a class="an" name="allgemeines">Allgemeines zu Referenzen in Perl</a></h2>
<p>Wenn Sie sich in der Sprache C auskennen, wissen Sie, was Zeiger sind, und wie effizient das Programmieren dadurch werden kann. Referenzen sind Zeiger auf andere Inhalte, z.B. auf zuvor definierte Variablen (egal ob <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="skalare.htm">Skalare</a>, <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="listen.htm">Listen</a> oder <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="hashes.htm">Hashes</a>). ber Referenzen knnen Sie den Inhalt eines Skalars, einer Liste oder eines Hashs genauso ansprechen wie ber den Originalnamen. Ferner knnen Sie Referenzen auf <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="subroutinen.htm">Subroutinen</a> setzen. Referenzen sind Skalare, die aber keine "Nutzwerte" speichern, sondern lediglich Arbeitsspeicheradressen von anderen Variablen oder von Subroutinen.</p>
<p>Fr Anfnger ist erst einmal nicht so recht ersichtlich, wozu solche Referenzen oder Zeiger gut sein sollen. Denn die Vorteile der Referenzen liegen zum einen auf einem Gebiet, mit dem Perl einen ansonsten verschont - nmlich der effizienten Arbeitsspeicherverwaltung. Es kostet einfach weniger Arbeitsspeicher und weniger Rechenlast, einer Funktion nicht eine Zeichenkette mit vielen tausend Zeichen zu bergeben, sondern nur eine Referenz auf diese Zeichenkette. Zum anderen sind Referenzen sinnvoll, wenn es darum geht, komplexe Datenstrukturen aufzubauen.</p>
<p>Referenzen werden vor allem auch in der <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="objekte.htm">objektorientierten Programmierung</a> eingesetzt, die mit Perl seit der Version 5 des Perl-Interpreters ebenfalls mglich ist. So erfolgt der Zugriff auf Methoden (Funktionen, Subroutinen) und Eigenschaften (Variablen) eines Objekts ber Referenzen. Auch viele moderne Module benutzen diese Technik, und solche Module zu verwenden bedeutet, mit Referenzen zu arbeiten. Deshalb lohnt es auf jeden Fall, sich mit Referenzen zu beschftigen.</p>
<p>Referenzen in Perl arbeiten anders als etwa im klassischen C. Die berchtigten "hngenden Zeiger", also Referenzen, die lnger leben als das, was mit ihnen referenziert wird, und die in C zu unkontrollierten Programmzustnden fhren knnen, gibt es in Perl nicht. Dort wird der Wert, auf den die Referenz zeigt, solange im Speicher gehalten, wie die letzte Referenz darauf lebt.<br>
Unter anderem aus diesem Grund ist eine Zeigerarithmetik (also das Rechnen mit Zeigern), wie sie oftmals in C praktiziert wird, in Perl nicht mglich.</p>
<p class="doc"><a href="#top"><img src="../../src/up.gif" width="14" height="10" border="0" alt="nach oben"></a><a href="#bottom"><img src="../../src/down.gif" width="14" height="10" border="0" alt="nach unten"></a></p>
<h2><a class="an" name="auf_skalare">Referenzen auf Skalare</a></h2>
<p>Sie knnen einen Zeiger auf einen <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="skalare.htm">Skalar</a> erzeugen und ber diesen Zeiger auf den Skalar und seinen gespeicherten Wert zugreifen.</p>
<h3 class="xmp"><a class="an" name="beispiel1">Beispiel eines vollstndigen CGI-Scripts:</a></h3>
<p><img src="../../src/dokf.gif" width="15" height="10" alt="Beispiel-Seite"> <a href="http://de.selfhtml.org/cgi-bin/812/referenzen1.pl">Anzeigebeispiel: So sieht's aus</a> (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)</p>
<pre>
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $Satz = "HTML - How To Make Love";
my $Satzzeiger = \$Satz;
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
print "Variablentyp und Speicheradresse von \$Satz: $Satzzeiger<br>\n";
print "Inhalt von \$Satz: ${$Satzzeiger}\n";
print "</body></html>\n";
</pre>
<h3 class="xpl">Erluterung:</h3>
<p>Das Beispiel definiert zunchst einen gewhnlichen Skalar namens <code>$Satz</code> und initialisiert ihn mit einem Wert. Anschlieend wird eine Referenz auf diesen Skalar deklariert. Die Referenz erhlt im Beispiel den Namen <code>$Satzzeiger</code>. Es handelt sich dabei von der Syntax her also offensichtlich um einen Skalar. Was diesen Skalar zu einer Referenz macht, ist der Wert, der ihm bei der Initialisierung zugewiesen wird. Der zugewiesene Wert <code>\$Satz</code> signalisiert Perl durch den anfnglichen Backslash, dass in <code>$Satzzeiger</code> die Referenz auf <code>$Satz</code> gespeichert werden soll. Wrde der Backslash fehlen, dann wrde <code>$Satzzeiger</code> einfach nur eine Kopie des Wertes von <code>$Satz</code> zugewiesen.</p>
<p>Das Beispiel erzeugt HTML-Code. Dabei gibt es zwei Informationen aus: einmal den Inhalt von <code>$Satzzeiger</code> (damit man sieht, was in so einer Referenz gespeichert ist - der ausgegebene Wert enthlt so etwas wie <code>SCALAR(0xb67d20)</code>), und einmal den Inhalt von <code>$Satz</code>, jedoch nicht ber <code>$Satz</code> selber, sondern mit Hilfe der Referenz <code>$Satzzeiger</code>. Der angegebene Beispiel-Code enthlt auerdem eine andere kleine Gemeinheit, die zu Verwirrung fhren kann: an der Stelle, wo <code>\$Satz</code> innerhalb der <code>print</code>-Anweisung vorkommt, hat der Backslash eine andere Bedeutung als zuvor beim Initialisieren der Referenz! An dieser Stelle dient der Backslash zum <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="zeichenketten.htm#maskierung">Maskieren</a> des Zeichens <code>$</code>. Durch die Maskierung wird erreicht, dass an der Stelle die Zeichenkette <code>$Satz</code> ausgegeben wird und nicht etwa der in <code>$Satz</code> gespeicherte Wert.</p>
<p>Um mit einer Referenz auf den in diesem Skalar gespeicherten Wert zugreifen zu knnen, mssen Sie die Syntax benutzen wie im Beispiel mit <code>${$Satzzeiger}</code> gezeigt. Die Referenz, in diesem Fall <code>$Satzzeiger</code>, wird dabei in geschweiften Klammern und mit einem zustzlich vorangestellten Dollarzeichen notiert. <code>${$Satzzeiger}</code> liefert im Beispiel also <code>HTML - How To Make Love</code>.</p>
<h3 class="inf">Beachten Sie:</h3>
<p>Die Syntax zur Dereferenzierung mit der geschweiften Klammer ist die Variante, die immer funktioniert. Perl bietet Ihnen auch hier die Mglichkeit, die Notation abzukrzen. Statt <code>${$Satzzeiger}</code> knnen Sie auch <code>$$Satzzeiger</code> notieren, wenn es im Kontext eindeutig ist.</p>
<p class="doc"><a href="#top"><img src="../../src/up.gif" width="14" height="10" border="0" alt="nach oben"></a><a href="#bottom"><img src="../../src/down.gif" width="14" height="10" border="0" alt="nach unten"></a></p>
<h2><a class="an" name="auf_arrays">Referenzen auf Arrays</a></h2>
<p>Sie knnen einen Zeiger auf einen <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="listen.htm">Array</a> erzeugen und ber diesen Zeiger auf den Array und alle seine Elemente zugreifen.</p>
<h3 class="xmp"><a class="an" name="beispiel2">Beispiel eines vollstndigen CGI-Scripts:</a></h3>
<p><img src="../../src/dokf.gif" width="15" height="10" alt="Beispiel-Seite"> <a href="http://de.selfhtml.org/cgi-bin/812/referenzen2.pl">Anzeigebeispiel: So sieht's aus</a> (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)</p>
<pre>
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Saetze = ( "HTML - How To Make Love. ",
"XHTML - Extended How To Make Love. ",
"XML - Extended Making Love." );
my $Saetzezeiger = \@Saetze;
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
print "Variablentyp und Speicheradresse von \@Saetze: $Saetzezeiger<br>\n";
print "Inhalt von \@Saetze: @{$Saetzezeiger} <br>\n";
print "Inhalt von \$Saetze[2]: $Saetzezeiger->[2] <br>\n";
print "</body></html>\n";
</pre>
<h3 class="xpl">Erluterung:</h3>
<p>Im Beispiel wird zunchst ein Array namens <code>@Saetze</code> deklariert und mit Anfangswerten initialisiert. Anschlieend wird eine Referenz auf diesen Array mit Namen <code>$Saetzezeiger</code> deklariert. Die Referenz selber ist ein Skalar, sichtbar an dem vorangestellten Dollarzeichen. Eine Referenz auf den Array wird dieser Skalar durch den zugewiesenen Wert <code>\@Saetze</code>. Der Backslash vor dem Klammeraffen signalisiert Perl, dass es eine Referenz ist. Wrde der Backslash an dieser Stelle fehlen, dann wrde in <code>$Saetzezeiger</code> brigens die Anzahl der Array-Elemente von <code>@Saetze</code> gespeichert!</p>
<p>Das Beispiel erzeugt HTML-Code und gibt dabei verschiedene Daten aus. In der ersten <code>print</code>-Anweisung wird zum besseren Verstndnis der gespeicherte Wert der Referenz <code>$Saetzezeiger</code> ausgegeben - das ist so etwas wie <code>ARRAY(0xb65b28)</code>.<br>
Die zweite <code>print</code>-Anweisung gibt den kompletten Inhalt des Arrays aus. Auf den Array als Ganzes wird dabei ber die Referenz mit der Syntax <code>@{$Saetzezeiger}</code> zugegriffen. Die Referenz steht also in geschweiften Klammern, und unmittelbar davor ist ein Klammeraffe notiert, der auf die Liste hinweist.<br>
In der dritten <code>print</code>-Anweisung wird ein bestimmtes Element von <code>@Saetze</code> ausgegeben, nmlich das dritte Listenelement. Direkt notiert wre dieses Element mit <code>$Saetze[2]</code> ansprechbar. Im Beispiel wird es jedoch ber die Referenz angesprochen, und dabei lautet die Syntax <code>$Saetzezeiger->[2]</code>. Notiert wird also die Referenz, gefolgt von dem Pfeiloperator <code>-></code> und dem gewnschten Listenelement in eckigen Klammern. Wichtig ist dabei, dass innerhalb der Zeichenkette <code>$Saetzezeiger->[2]</code> keine Leerzeichen vorkommen.</p>
<p>Die Backslashes vor <code>\@Saetze</code> und <code>\$Saetze[2]</code> innerhalb der <code>print</code>-Anweisungen haben wie schon im Beispiel zu Skalaren nichts mit Referenzen zu tun, sondern dienen der <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="zeichenketten.htm#maskierung">Maskierung</a>.</p>
<h3 class="inf">Beachten Sie:</h3>
<p>Wie auch bei Skalarreferenzen bietet Perl Ihnen unterschiedliche Notationsmglichkeiten. So knnen Sie statt <code>@{$Saetzezeiger}</code> auch <code>@$Saetzezeiger</code> notieren und statt <code>$Saetzezeiger->[2]</code> knnen Sie auch die "Urvariante" <code>${$Saetzezeiger}[2]</code> oder die Variante <code>$$Saetzezeiger[2]</code> verwenden.</p>
<p class="doc"><a href="#top"><img src="../../src/up.gif" width="14" height="10" border="0" alt="nach oben"></a><a href="#bottom"><img src="../../src/down.gif" width="14" height="10" border="0" alt="nach unten"></a></p>
<h2><a class="an" name="auf_hashes">Referenzen auf Hashes</a></h2>
<p>Sie knnen eine Referenz auf einen <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="hashes.htm">Hash</a> erzeugen und ber diese Referenz auf den Hash als Ganzes sowie auf dessen einzelne Schlssel und Werte zugreifen.</p>
<h3 class="xmp"><a class="an" name="beispiel3">Beispiel eines vollstndigen CGI-Scripts:</a></h3>
<p><img src="../../src/dokf.gif" width="15" height="10" alt="Beispiel-Seite"> <a href="http://de.selfhtml.org/cgi-bin/812/referenzen3.pl">Anzeigebeispiel: So sieht's aus</a> (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)</p>
<pre>
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my %Sprachen = ( HTML => "How To Make Love. ",
XHTML => "Extended How To Make Love. ",
XML => "Extended Making Love. " );
my $Sprachenzeiger = \%Sprachen;
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
print "Variablentyp und Speicheradresse von %Sprachen: $Sprachenzeiger<br>\n";
print "Inhalt von \%Sprachen: ", %{$Sprachenzeiger}," <br>\n";
print "Bedeutung von XML: $Sprachenzeiger->{XML} <br>\n";
print "</body></html>\n";
</pre>
<h3 class="xpl">Erluterung:</h3>
<p>Im Beispiel wird zunchst ein Hash namens <code>%Sprachen</code> deklariert und mit Anfangswerten initialisiert. Anschlieend wird eine Referenz auf diesen Hash mit Namen <code>$Sprachenzeiger</code> deklariert. Die Referenz selber ist ein Skalar, der durch den zugewiesenen Wert <code>\%Sprachen</code> zur Referenz wird. Der Backslash vor dem Prozentzeichen signalisiert die Referenz auf den Hash.</p>
<p>Das Beispiel erzeugt HTML-Code und gibt dabei verschiedene Daten aus. In der ersten <code>print</code>-Anweisung wird zum besseren Verstndnis der gespeicherte Wert der Referenz <code>$Sprachenzeiger</code> ausgegeben - das ist so etwas wie <code>HASH(0xb65b28)</code>.<br>
Die zweite <code>print</code>-Anweisung gibt den kompletten Inhalt des Hashes aus. Auf den Hash als Ganzes wird ber die Referenz mit der Syntax <code>%{$Sprachenzeiger}</code> zugegriffen. Die Referenz steht also in geschweiften Klammern, und unmittelbar davor ist ein Prozentzeichen notiert, das auf den Hash hinweist.<br>
In der dritten <code>print</code>-Anweisung wird direkt das Hash-Element mit dem Schlssel <code>XML</code> angesprochen. Direkt notiert wre dieses Element mit <code>$Sprachen{XML}</code> ansprechbar. Im Beispiel wird es jedoch ber die Referenz angesprochen, und dabei lautet die Syntax <code>$Sprachenzeiger->{XML}</code>. Notiert wird also die Referenz, gefolgt von dem Pfeiloperator <code>-></code> und dem gewnschten Hash-Schlssel in geschweiften Klammern. Innerhalb von <code>$Sprachenzeiger->{XML}</code> drfen in diesem Kontext (also innerhalb von Zeichenketten) keine Leerzeichen vorkommen.</p>
<h3 class="inf">Beachten Sie:</h3>
<p>Wie bei Array-Referenzen bietet Perl Ihnen auch hier unterschiedliche Notationsmglichkeiten. So knnen Sie wieder statt <code>%{$Sprachenzeiger}</code> auch <code>%$Sprachenzeiger</code> notieren, und statt <code>$Sprachenzeiger->{XML}</code> knnen Sie auch die Varianten <code>${$Sprachenzeiger}{XML}</code> oder <code>$$Sprachenzeiger{XML}</code> verwenden.</p>
<p class="doc"><a href="#top"><img src="../../src/up.gif" width="14" height="10" border="0" alt="nach oben"></a><a href="#bottom"><img src="../../src/down.gif" width="14" height="10" border="0" alt="nach unten"></a></p>
<h2><a class="an" name="auf_subroutinen">Referenzen auf Subroutinen</a></h2>
<p>Sie knnen eine Referenz auf eine <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="subroutinen.htm">Subroutine</a> setzen und ber diese Referenz die Subroutine aufrufen.</p>
<h3 class="xmp"><a class="an" name="beispiel4">Beispiel eines vollstndigen CGI-Scripts:</a></h3>
<p><img src="../../src/dokf.gif" width="15" height="10" alt="Beispiel-Seite"> <a href="http://de.selfhtml.org/cgi-bin/812/referenzen4.pl">Anzeigebeispiel: So sieht's aus</a> (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)</p>
<pre>
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
sub Zufallswert {
return int(rand(1000) + 1);
}
my $Ergebnis = Zufallswert();
my $Subroutinenzeiger = \&Zufallswert;
my $Referenzergebnis = &{$Subroutinenzeiger}();
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
print "Ergebnis: $Ergebnis<br>\n";
print "Subroutinenzeiger: $Subroutinenzeiger<br>\n";
print "Referenzergebnis: $Referenzergebnis<br>\n";
print "</body></html>\n";
</pre>
<h3 class="xpl">Erluterung:</h3>
<p>Im Beispiel wird eine Subroutine namens <code>Zufallswert</code> notiert. Diese Subroutine ermittelt mit Hilfe der Perl-Funktionen <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="../funktionen/berechnungen.htm#rand">rand</a> und <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="../funktionen/berechnungen.htm#int">int</a> eine zufllige Ganzzahl zwischen 1 und 1000 und gibt die ermittelte Zahl mit <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="../funktionen/kontrolle.htm#return">return</a> zurck.</p>
<p>Mit der Anweisung <code>my $Ergebnis = &Zufallswert();</code> wird die Subroutine aufgerufen. Der Rckgabewert, also eine ermittelte Zufallszahl, wird im Skalar <code>Ergebnis</code> gespeichert.<br>
Mit der Anweisung <code>my $Subroutinenzeiger = \&Zufallswert;</code> wird dagegen nur ein Zeiger auf die Subroutine <code>Zufallswert</code> deklariert. Die Funktion wird dabei <strong>nicht</strong> aufgerufen! Dass es sich um eine Referenz handelt, bewirkt die Syntax <code>\&Zufallswert</code> beim zugewiesenen Wert. Der Backslash am Anfang signalisiert die Referenz und das Ampersand-Zeichen <code>&</code> eine Subroutine. Dahinter folgt der Name der Subroutine.<br>
Mit der Anweisung <code>my $Referenzergebnis = &{$Subroutinenzeiger}();</code> wird die Subroutine <code>Zufallswert</code> wieder aufgerufen. Diesmal aber nicht wie in der ersten Anweisung direkt, sondern ber die zuvor definierte Referenz. Die Syntax ist dabei so, dass die Referenz in geschweiften Klammern steht und ein Ampersand-Zeichen <code>&</code> vorangestellt bekommt.<br>
Die leeren runden Klammern hinter dem Namen der Subroutine sind brigens nicht zwingend ntig. Der Rckgabewert des zweiten Aufrufs von <code>Zufallswert</code> wird in dem Skalar <code>$Referenzergebnis</code> gespeichert.</p>
<p>Das Beispiel sendet HTML-Code an den Browser und gibt dabei die drei Werte von <code>$Ergebnis</code>, <code>$Subroutinenzeiger</code> und <code>$Referenzergebnis</code> aus. Whrend die beiden Skalare <code>$Ergebnis</code> und <code>$Referenzergebnis</code> eine Zufallszahl zwischen 1 und 1000 enthalten, ist der Inhalt von <code>$Subroutinenzeiger</code> nur der Zeigertyp und die Arbeitsspeicheradresse, z.B. so etwas wie <code>CODE(0xb65b28)</code>.</p>
<h3 class="inf">Beachten Sie:</h3>
<p>
Perl bietet Ihnen auch bei der Dereferenzierung von Code-Referenzen unterschiedliche Notationsmglichkeiten. So knnen Sie analog zu Skalar- und Array-Referenzen statt <code>&{$Subroutinenzeiger}()</code> auch <code>&$Subroutinenzeiger()</code> oder <code>$Subroutinenzeiger->()</code> notieren.</p>
<p class="doc"><a href="#top"><img src="../../src/up.gif" width="14" height="10" border="0" alt="nach oben"></a><a href="#bottom"><img src="../../src/down.gif" width="14" height="10" border="0" alt="nach unten"></a></p>
<h2><a class="an" name="auf_dateihandles">Referenzen auf Dateihandles</a></h2>
<p>Bei <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="../funktionen/einausgabe.htm">Funktionen fr Ein-/Ausgabe und Lesen/Schreiben von Daten</a> haben Sie viel mit Dateihandles zu tun. Dateihandles verhalten sich anders als gewhnliche Variablen. So knnen Sie ihnen keine direkten Werte zuweisen, sondern nur die Werte nutzen, die dem Dateihandle bei Bedarf vom Perl-Interpreter selbst zugewiesen werden. Die Werte beinhalten perl-interne Informationen ber den <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="../funktionen/einausgabe.htm#allgemeines">Ein-/Ausgabekanal</a>, auf den Sie mittels des Dateihandles zugreifen. Fr Sie als Benutzer ist allerdings nur der Name des Handles interessant, um den Rest kmmert sich der Perl-Interpreter selbst.<br>
Auf ein solches Dateihandle knnen Sie ebenfalls eine Referenz setzen. Hier liegt eine weitere Besonderheit gegenber gewhnlichen Variablen in Perl: Sie mssen diese Referenz zur Benutzung des Dateihandles nicht explizit dereferenzieren. Das erledigt der Perl-Interpreter automatisch, wenn es notwendig ist.</p>
<h3 class="xmp"><a class="an" name="beispiel5">Beispiel eines vollstndigen CGI-Scripts:</a></h3>
<p><img src="../../src/dokf.gif" width="15" height="10" alt="Beispiel-Seite"> <a href="http://de.selfhtml.org/cgi-bin/812/referenzen5.pl">Anzeigebeispiel: So sieht's aus</a> (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)</p>
<pre>
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
open(DATEI, "</tmp/server.cfg") || die "nicht gefunden";
my $HandleReferenz = \*DATEI;
my @Zeilen = <$HandleReferenz>;
my $Zeilenzahl = @Zeilen;
my $HandleName = *{$HandleReferenz};
close($HandleReferenz);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
print "eingelesene Zeilen: $Zeilenzahl<br>\n";
print "$HandleReferenz<br>\n";
print "$HandleName<br>\n";
print "</body></html>\n";
</pre>
<h3 class="xpl">Erluterung:</h3>
<p>Das Beispiel ffnet mit der <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="../funktionen/einausgabe.htm#open">open</a>-Funktion von Perl eine Datei. Dabei ist <code>DATEI</code> der Name fr das Dateihandle, ber das auf die Datei zugegriffen wird. Dieser Name ist im Rahmen der <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="../intro.htm#namensvergabe">Regeln zur Namensvergabe</a> frei whlbar, jedoch sollten Sie per Konvention <strong>keine</strong> Kleinbuchstaben verwenden. Wenn Sie die <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="../intro.htm#aufruf">w-Option</a> des Perl-Interpreters verwenden, erhalten Sie bei unpassend gewhlten Namen eine Warnung. Normalerweise knnte anschlieend mit einer Anweisung wie <code>my @Zeilen = <DATEI>;</code> der Inhalt der Datei eingelesen werden. Im obigen Beispiel geschieht das Einlesen jedoch indirekt ber eine Referenz.<br>
Mit der Anweisung <code>my $HandleReferenz = \*DATEI;</code> wird ein Zeiger auf den Namen (bzw. den Eintrag in der perl-internen Symboltabelle) <code>DATEI</code> deklariert. Der Backslash am Anfang der Zuweisung signalisiert die Referenz und das Sternzeichen <code>*</code> einen Symboltabelleneintrag (einen so genannten Typeglob). Dahinter folgt der Name des Dateihandles.<br>
Mit <code>my @Zeilen = <$HandleReferenz>;</code> kann der Inhalt der Datei nun ber die Referenz auf das Dateihandle eingelesen werden. Statt <code><DATEI></code> wird also einfach <code><$HandleReferenz></code> notiert. Die Referenz dazu wird vom Perl-Interpreter selbst aufgelst.<br>
Die Anweisung <code>my $Zeilenzahl = @Zeilen;</code> ermittelt die Anzahl der eingelesenen Zeilen zur spteren Kontrollausgabe.<br>
In der Anweisung <code>my $HandleName = *{$HandleReferenz};</code> wird die Referenz auf das Dateihandle nochmals explizit dereferenziert. In dieser Notation, also in geschweiften Klammern und mit voranstehendem Sternzeichen, wird der in <code>$HandleReferenz</code> gespeicherte <strong>Name</strong> des Handles ermittelt, im Beispiel also <code>DATEI</code>. Dabei wird allerdings auch der aktuelle Namensraum (package) mit ermittelt (siehe dazu auch die Perl-Funktion <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="../funktionen/module.htm#package">package</a>). Der tatschlich ermittelte Wert im obigen Beispiel ist <code>*main::DATEI</code>. Dabei ist <code>main</code> einfach der voreingestellte Namensraum von Perl, wenn - wie hier im Beispiel auch - kein anderer Namensraum angegeben wurde. <code>main::DATEI</code> wird als <strong>voll qualifizierter Name</strong> bezeichnet, da er genau aussagt, in welchem Namensraum <code>DATEI</code> zu finden ist.</p>
<p>Das Beispiel erzeugt HTML-Code und gibt dabei die ermittelten Werte aus. Der Wert von <code>$HandleReferenz</code> ist so etwas wie <code>GLOB(0xb67968)</code>. Dabei steht <code>GLOB</code> fr den Referenztyp "Typeglob".</p>
<p class="doc"><a href="#top"><img src="../../src/up.gif" width="14" height="10" border="0" alt="nach oben"></a><a href="#bottom"><img src="../../src/down.gif" width="14" height="10" border="0" alt="nach unten"></a></p>
<h2><a class="an" name="auf_referenzen">Referenzen auf Referenzen</a></h2>
<p>Es mag sich zunchst nach einer theoretischen Spielerei anhren, mit Referenzen auf Referenzen zu arbeiten. Bei komplexen Datenstrukturen kann es jedoch durchaus sinnvoll sein, solche Referenzen einzusetzen. Gerade beim Zugriff auf Einzelwerte aus einer solchen komplexen Datenstruktur erreicht Perl eine geradezu klassische Schnheit in der Notation.</p>
<h3 class="xmp"><a class="an" name="beispiel6">Beispiel eines vollstndigen CGI-Scripts:</a></h3>
<p><img src="../../src/dokf.gif" width="15" height="10" alt="Beispiel-Seite"> <a href="http://de.selfhtml.org/cgi-bin/812/referenzen6.pl">Anzeigebeispiel: So sieht's aus</a> (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)</p>
<pre>
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $Haus = "Einfamilienhaus in Fertigbauweise";
my @Autos = ("VW","Opel","Audi","Porsche");
my %Familie = (Frau => "Eva", Tochter => "Anja", Sohn => "Florian");
my %Zeigerhash = (Hauszeiger => \$Haus, Autozeiger => \@Autos, Familienzeiger => \%Familie);
my $Zeiger = \%Zeigerhash;
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
print "(1.) $Zeiger->{Hauszeiger}<br>\n";
print "(2.) ${$Zeiger->{Hauszeiger}}<br>\n";
print "(3.) $Zeiger->{Autozeiger}<br>\n";
print "(4.) @{$Zeiger->{Autozeiger}}<br>\n";
print "(5.) $Zeiger->{Autozeiger}->[2]<br>\n";
print "(6.) $Zeiger->{Autozeiger}[3]<br>\n";
print "(7.) $Zeiger->{Familienzeiger}<br>\n";
print "(8.)", %{$Zeiger->{Familienzeiger}},"<br>\n";
print "(9.) $Zeiger->{Familienzeiger}->{Frau}<br>\n";
print "(10.) $Zeiger->{Familienzeiger}{Sohn}<br>\n";
print "</body></html>\n";
</pre>
<h3 class="xpl">Erluterung:</h3>
<p>Das Beispiel deklariert zunchst einen Skalar <code>$Haus</code>, einen Array <code>@Autos</code> und einen Hash <code>%Familie</code>. Daraufhin werden Zeiger bzw. Referenzen auf diese Variablen definiert. Da es sich jedoch um eine Serie von Zeigern handelt, werden sie nicht einzeln als Skalare deklariert, sondern in einem Hash namens <code>%Zeigerhash</code>. Jedes Element eines Hashs oder einer Liste kann ja einen Skalar speichern, und da Referenzen Skalare sind, ist es also kein Problem, Hashes oder Listen von Referenzen zu erzeugen. Der Hash im Beispiel erhlt als Zuweisung beispielsweise einen Schlssel namens <code>Hauszeiger</code>, mit dem eine Referenz auf den Skalar <code>Haus</code> verknpft ist, sichtbar am beginnenden Backslash <code>\$Haus</code>. Ebenso wird es mit den anderen Referenzen innerhalb des Hashes gemacht.</p>
<p>Nun knnte man ja ber die Hashvariable <code>%Zeigerhash</code> auf die Referenzen und ihre Werte zugreifen. Im Beispiel wird jedoch noch ein Skalar namens <code>$Zeiger</code> deklariert, der eine Referenz auf den Hash <code>%Zeigerhash</code> ist, sichtbar an der Notation <code>\%Zeigerhash</code> bei der Zuweisung. <code>$Zeiger</code> ist damit also eine Referenz auf einen Hash aus Referenzen.</p>
<p>Das Beispiel-Script hat damit allerlei Daten beisammen und kann bei der Zusammenstellung von HTML-Code die verschiedensten Werte ausgeben. Der Einfachheit halber erscheinen die Ausgaben nummeriert:</p>
<p>(1.) gibt so etwas aus wie: <code>SCALAR(0xb65b7c)</code>, denn <code>$Zeiger->{Hauszeiger}</code> bedeutet den Wert des Hash-Elements mit dem Schlssel <code>Hauszeiger</code>, und das ist die Referenz <code>\$Haus</code>.<br>
(2.) gibt aus: <code>Einfamilienhaus in Fertigbauweise</code>, denn <code>${$Zeiger->{Hauszeiger}}</code> bedeutet den Wert des Wertes vom Hash-Element mit dem Schlssel <code>Hauszeiger</code>, also letztlich den Wert der Referenz <code>\$Haus</code>. Um den Wert des Wertes zu ermitteln, wird um den Ausdruck aus (1.) einfach noch einmal eine geschweifte Klammer gesetzt und ein <strong>Dollarzeichen</strong> vorangestellt.<br>
(3.) gibt so etwas aus wie: <code>ARRAY(0xb65b4c)</code>, denn <code>$Zeiger->{Autozeiger}</code> bedeutet den Wert des Hash-Elements mit dem Schlssel <code>Autozeiger</code>, und das ist die Referenz <code>\@Auto</code>.<br>
(4.) gibt aus: <code>VW Opel Audi Porsche</code>, denn <code>@{$Zeiger->{Autozeiger}}</code> bedeutet den Wert des Wertes vom Hash-Element mit dem Schlssel <code>Autozeiger</code>, also letztlich den Wert der Referenz <code>\@Autos</code>, und das ist die gesamte Liste <code>@Autos</code>. Um den Wert des Wertes zu ermitteln, wird um den Ausdruck aus (3.) einfach noch einmal eine geschweifte Klammer gesetzt und ein <strong>Klammeraffe</strong> vorangestellt.<br>
(5.) gibt aus: <code>Audi</code>, denn <code>$Zeiger->{Autozeiger}->[2]</code> bedeutet den Wert des dritten Elements des Wertes vom Hash-Element mit dem Schlssel <code>Autozeiger</code>, also letztlich den dritten Wert der Referenz <code>\@Autos</code>, und das ist das dritte Element von <code>@Autos</code>.<br>
(6.) gibt aus: <code>Porsche</code>. Dies ist eine verkrzte Schreibweise fr das gleiche, was bei (5.) passiert. Es gengt, den ersten Pfeiloperator <code>-></code> zu notieren.<br>
(7.) gibt so etwas aus wie: <code>HASH(0xb65b58)</code>, denn <code>$Zeiger->{Familienzeiger}</code> bedeutet den Wert des Hash-Elements mit dem Schlssel <code>Familienzeiger</code>, und das ist die Referenz <code>\%Familie</code>.<br>
(8.) gibt aus: <code>SohnFlorianTochterAnjaFrauEva</code>, denn <code>%{$Zeiger->{Familienzeiger}}</code> bedeutet den Wert des Wertes vom Hash-Element mit dem Schlssel <code>Familienzeiger</code>, also letztlich den Wert der Referenz <code>\%Familie</code>, und das ist der gesamte Hash <code>%Familie</code>. Um den Wert des Wertes zu ermitteln, wird um den Ausdruck aus (7.) einfach noch einmal eine geschweifte Klammer gesetzt und ein <strong>Prozentzeichen</strong> vorangestellt.<br>
(9.) gibt aus: <code>Eva</code>, denn <code>$Zeiger->{Familienzeiger}->{Frau}</code> bedeutet den Wert des Hash-Elements mit dem Schlsselnamen <code>Frau</code> des Wertes vom Hash-Element mit dem Schlssel <code>Familienzeiger</code>.<br>
(10.) gibt aus: <code>Florian</code>. Dies ist eine verkrzte Schreibweise fr das gleiche, was bei (9.) passiert und hat den gleichen Grund wie bei (6.).</p>
<table cellpadding="4" cellspacing="0" border="0" width="100%">
<tr><td colspan="2" class="doc">
<a href="#top"><img src="../../src/up.gif" width="14" height="10" border="0" alt="nach oben"></a>
</td></tr>
<tr><td class="doc"><a href="vordefiniert.htm"><img src="../../src/next.gif" width="10" height="10" border="0" hspace="10" alt="weiter"></a></td>
<td width="100%"><img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="vordefiniert.htm">Vordefinierte Variablen in Perl</a>
</td></tr>
<tr>
<td class="doc"><a href="hashes.htm"><img src="../../src/prev.gif" width="10" height="10" border="0" hspace="10" alt="zurck"></a></td>
<td><img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="hashes.htm">Hashes (Variablen)</a>
</td>
</tr>
<tr><td colspan="2" class="doc"> </td>
</tr>
<tr>
<td colspan="2" class="nav"><a class="an" name="bottom"><img src="../../src/refkap.gif" width="16" height="13" alt="Teil von"></a> <a href="../../index.htm">SELFHTML</a>/<a href="../../navigation/index.htm" target="_parent" class="navh">Navigationshilfen</a> <img src="../../src/refkap.gif" width="16" height="13" alt="Teil von"> <a href="../index.htm">Perl</a> <img src="../../src/refkap.gif" width="16" height="13" alt="Teil von"> <a href="index.htm">Perl-Sprachelemente</a></td>
</tr>
</table>
<p>© 2007 <img src="../../src/dok.gif" width="15" height="10" alt="Seite"> <a href="../../editorial/impressum.htm">Impressum</a></p>
</body>
</html>
|
