Variablen/Objekte an Funktionen übergeben (Allgemeines zu Perl)

[thread]18395[/thread]

Variablen/Objekte an Funktionen übergeben

Tags: perl5 Ähnliche Threads

Leser: 18

Articles: hide open all | hide show old branches

+4 replies
Kean

2013-06-20 14:27

User since
2004-08-18
463 Artikel
BenutzerIn

Ich schreibe gerade ein Script mit sehr vielen Funktionen und übergebe Variablen und Objekte (z.b. Tk-Widgets) immer direkt und nicht über Referenzen.

Jetzt habe ich mich ein wenig eingelesen und verschiedene Sachen aufgeschnappt. Unter anderem, dass Perl bei der Übergabe von Arrays, Hashes, ... automatisch referenzieren würde. Stimmt das?

Gerade bei großen Tk-Hlist Widgets mache ich mir schon sorgen dass diese nach dem übergeben an eine Funktion zweimal im Speicher sind.

Arbeitsspeicher ist ja heute nicht mehr knapp aber ich würde trotzdem gerne effizient programmieren.
- GUIfreund
  
  2013-06-20 17:30
  
  User since
  2011-08-08
  559 Artikel
  BenutzerIn
  
  2013-06-20T12:27:54 Kean
  Ich ... übergebe Variablen und Objekte (z.b. Tk-Widgets) immer direkt und nicht über Referenzen.
  
  Objekte sind Referenzen, genauer gesagt erhältst du bei der Erzeugung eines Objekts eine Referenz auf das Objekt als Ergebnis zurück. Das kannst du dir mit ref $obj näher ansehen.
  
  2013-06-20T12:27:54 Kean
  Gerade bei großen Tk-Hlist Widgets mache ich mir schon sorgen dass diese nach dem übergeben an eine Funktion zweimal im Speicher sind.
  
  Durch Verwenden von Referenzen z. B. zur Übergabe an und Rückgabe aus Funktionen kann man das Kopieren von komplexen Strukturen vermeiden. Das gilt nicht nur für Objekte, sondern z. B. auch für Arrays und Hashes.
  Gruß
  GUIfreund
- renee
  
  2013-06-20 17:30
  User since
  2003-08-04
  14371 Artikel
  ModeratorIn
  Man sollte Referenzen übergeben, gerade damit die Sachen nicht doppelt im Speicher liegen.
  
  Code: (dl )
  
  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
  
  #!/usr/bin/perl use strict; use warnings; use Data::Dumper; my @array = (1..3); test(@array); print Dumper \@array; test_ref(\@array); print Dumper \@array; sub test { my (@values) = @_; # erzeugt kopie von @array, # also doppelt im Speicher $values[1] = 9; print Dumper \@array; $_[2] = 5; # Mit $_[...] greift man auf # das Original-Array zu print Dumper \@array; } sub test_ref { my ($array_ref) = @_; # kopie der referenz, die Werte im # Array gibt's aber nur einmal $array_ref->[2] = 6; # verändert Wert in @array print Dumper \@array; }
  
  Ausgabe:
  
  Code: (dl )
  
  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
  
  $VAR1 = [ 1, 2, 3 ]; $VAR1 = [ 1, 2, 5 ]; $VAR1 = [ 1, 2, 5 ]; $VAR1 = [ 1, 2, 6 ]; $VAR1 = [ 1, 2, 6 ];
  
  Es gibt natürlich Fälle, in denen man auf Referenzen verzichten sollte (wenn man "Angst" hat, dass etwas an den Originaldaten verändert werden könnte).
  
  Wenn im Array Referenzen gespeichert werden, werden diese nie kopiert:
  
  Code: (dl )
  
  1 2 3 4 5 6 7 8
  
  my @array = ([1,2,3],[4,5,6]); test(@array); sub test { my @values = @_; $_[0]->[2] = 5; # Originaldaten werden verändert ]
  
  Last edited: 2013-06-20 17:33:16 +0200 (CEST)
  OTRS-Erweiterungen (http://feature-addons.de/)
  Frankfurt Perlmongers (http://frankfurt.pm/)
  --
  
  Unterlagen OTRS-Workshop 2012: http://otrs.perl-services.de/workshop.html
  Perl-Entwicklung: http://perl-services.de/
- Raubtier
  
  2013-06-20 20:41
  User since
  2012-05-04
  1054 Artikel
  BenutzerIn
  Eigentlich gibt es in Perl bei Parameterübergabe nur drei Dinge zu beachten:
  
  Es gibt genau eine Parameterliste, in der alle Argumente übergeben werden
  Arrays und Hashes werden zur Liste ihrer Elemente
  Die Parameterübergabe erfolgt immer per Referenz (bei Arrays ist aber die Referenz auf die Elemente gemeint)
  
  Der erste/zweite Punkt führt dazu, dass man nicht zwei Arrays direkt übergeben kann, ohne Informationen über die Arraygrenzen zu verlieren (es kommt in der Funktion genau ein Array an, das eben von beiden Arrays die Elemente enthält.
  
  Der dritte Punkt ist auch sehr interessant, er gilt bei Arrays aber für die Array-Elemente selbst, nicht für die Arrays selbst:
  
  Code: (dl )
  
  1 2 3 4 5 6 7 8 9 10 11
  
  $ perl -MData::Dumper -wE'@a=qw(1 2 3); @b=qw(4 5 6);add1(@a, @b);say Dumper \@a, \@b;sub add1{++$_ for @_}' $VAR1 = [ '2', '3', '4' ]; $VAR2 = [ '5', '6', '7' ];
  
  Aus diesem Grunde bietet es sich daher oft an, Arrays als Referenzen zu übergeben (dann übergibt man eben nicht alle Elemente).
  
  Außerdem wird ein Call-by-Value durch Code wie den folgenden simuliert:
  
  Code (perl): (dl )
  
  1 2 3
  
  sub foo { my ($uebergabeParameter1, $uebergabeParameter2) = @_; ...
  
  Interessant ist, dass man trotz Call-by-Reference auch Immediates übergeben kann (es ist dann z.B. eine Referenz auf eine Zahl im Speicher). Ich habe dafür man irgendwo den Terminus "Call by value reference" gelesen.
  
  Als Bonus kannst du außerdem noch über Prototypen in perlsub nachlesen, die die Übergabeart verändern können.
  Last edited: 2013-06-20 20:45:34 +0200 (CEST)

View all threads created 2013-06-20 14:27.