Getter/Setter

[Karakash]

Grüße,

wie lernen z.Z. absolute Basics in Perl und bei mir scheitert es schon bei einem Variablenaufruf eines anderen Packages.

  
#!perl -w  
  
use strict;  
package IDependencies;  
my $requirementFulfilled;  
package initialize;  
sub new (){  
my $self=shift;  
my $newInst={};  
bless($newInst,$self);  
}  
package Method;  
use base 'initialize';  
my $name;  
sub IsFullfilled()  
{  
	print $requirementFulfilled = 0;  
  
}  
package Combinatorics;  
use base 'initialize';  
my %hashtable;  
  
  
  
package main;  
  
my $Method = new Method ->IsFullfilled();  
  
  

Das ist mein bisheriger Code.
Am Ende soll in einer Hash-Table als Key die Instanz einer Method stehen und als Value entweder eine Instanz einer anderen Method, nichts oder aber erneut ein Hash-Table in dem widerrum das selbe stehen kann.

Nun hab ich ein gewaltiges Problem im package main auf die Variable von Combinatorics zuzugreifen und Einträge zu ändern.

Testweise hab ich das Script erweitert:

  
package combinatorics;  
%hashtable = (Teststring=>"Teststring",Teststring2 =>"Teststring2");  
print "$hashtable{'Teststring'}Teststring  $hashtable{'Teststring2'} Teststring2";  

Funktioniert auch tadellos, aber:

Ich will ja in meiner Main auf den Hash zugreifen und ihn ändern können. und im Prinzip etwas schreiben wie:

  
package main;  
  
my $Method = new Method;  
my $2Method = new Method;  
my $combinatorics = new Combinatorics;  
$combinatorics::%hashtable = ($Method=>$2Method)  

Falls es irgendjemandem helfen sollte mein Problem zu verstehen;
In C# würd ich,um das selbe zu realisieren, schreiben:

public class Combinatorics {

Dictionary <initialize,initialize> hashtable = new Dictionary <initialize,initialize>();

}
Method method = new Method();
Method 2method = new Method();
Combinatorics combinatorics = new Combinatorics();

combinatorics.hashtable.Add(method,2method)

[hotti]

Grüße,

wie lernen z.Z. absolute Basics in Perl und bei mir scheitert es schon bei einem Variablenaufruf eines anderen Packages.

#!perl -w

use strict;
package IDependencies;
my $requirementFulfilled;
package initialize;
###...##

  
Bis hier gelesen, kurze Erläuterung: jede Zeile  
  
package Foo;  
my $foo = 'Otto';  
package Bar;  
my $bar = 'Ulli';  
  
eröffnet einen neuen Namespace. Es ist also nicht möglich, in package Foo auf $bar zuzugreifen und nicht möglich in package Bar den Wert von $foo abzufragen, diese Variablen sind in unterschiedlichen Namens-Räumen. Zum einfachen Importieren/Exportieren in andere Namespaces gibt es @EXPORT und @EXPORT\_OK;  
  
Oder: Ein Namespace ist eine Klasse, in der es eine new()-Method gibt, mit der eine Instanz der Klasse erzeugt wird, die wiederum in einem anderen Namespace verwendung findet:  
  
~~~perl
  
package Foo;  
  
sub new{  
   my $pkg = shift;  
   return bless {name => 'Otto'}, $pkg;  
}  
  
package main;  
my $obj = Foo->new;  
print $obj->{name}; # Otto  

Beispiel für beide Varianten, Export und Instance.

Hotti

[Karakash]

Oder: Ein Namespace ist eine Klasse, in der es eine new()-Method gibt, mit der eine Instanz der Klasse erzeugt wird, die wiederum in einem anderen Namespace verwendung findet

Soweit klar - ich möchte mir ja später beliebig viele Instanzen erstellen und diese im Hash verarbeiten.
Nur möchte ich innerhalb eines Packages(main) auf die Variable einer anderen Klasse zugreifen - wohlgemerkt auf die Instanz dieser Klasse und nicht auf das Package selbst.

Ich werde mich mal genauer mit der Export-Funktion befassen.

[hotti]

hi,

Ich werde mich mal genauer mit der Export-Funktion befassen.

Machdat ;) Schon hier beginnt OOP: Zum Exportieren muss Deine package von der Superklasse Exporter erben: require Exporter; und ist dann selbst ein Exporter mit @ISA = qw(Exporter);. Mach Dir die Unterschiede zwischen EXPORT und EXPORT_OK klar.

ISA steht für: Is a... (Is what?)

Hotti

[Struppi]

Ich werde mich mal genauer mit der Export-Funktion befassen.

Machdat ;) Schon hier beginnt OOP: ...

...

ISA steht für: Is a... (Is what?)

Du verwechselst hier etwas.

Mit @ISA kannst du eine Vererbungshirachie aufbauen, das stimmt. Aber Exporter hat nichts mit OOP zu tun, im gegenteil. Das Modul dient vor allem dazu OOP zu vermeiden.

Struppi.

[hotti]

hi,

Mit @ISA kannst du eine Vererbungshirachie aufbauen, das stimmt. Aber Exporter hat nichts mit OOP zu tun, im gegenteil. Das Modul dient vor allem dazu OOP zu vermeiden.

Ja. Module in Säcken produzieren, die haufenweise Funktionen exportieren, wo Du länger brauchst, die wieder zu finden, als gleich neu zu schreiben ;)

Exporting without inhertiting from Exporter

Note: This feature was introduced in version 5.57 of Exporter, released with perl 5.8.3.

und gabs zur Zeit, als Eric Foster J. das Buch "Perl Module" schrieb noch gar nicht.

Wenn meine Bücher veraltet sind, heißt das noch lange nicht, dass ich ein alter Knacker bin. Lesen kann ich immer noch.

Hotti

[Alexander (HH)]

Moin Moin!

Schon hier beginnt OOP: Zum Exportieren muss Deine package von der Superklasse Exporter erben: require Exporter; und ist dann selbst ein Exporter mit @ISA = qw(Exporter);.

Cargo cult!

1. require ist nicht nur mehr sinnlose Tipperei, sondern es lädt das Exporter-Modul erst zur Laufzeit, während use es schon zur Compile-Zeit lädt.

2. Direkt an @ISA herumzufummeln ist seit parent (im Core seit 5.10.1 = 2009-08-23) und base (im Core seit 5.4.5 = 1999-04-29) nicht mehr nötig.

3. Um zu exportieren, muß ein Modul überhaupt nicht von Exporter erben, im Gegenteil: Man sollte das vermeiden, weil Exporter eben nicht nur aus einer import-Methode besteht, sondern noch jede Menge anderes Zeug enthält. Siehe Exporting without inheriting from Exporter.

4. Ja, die Exporter-Dokumentation ist noch voll von dem Vererbungs-Unsinn. Leider. Bug!

Alexander

[hotti]

Moin Moin!

Schon hier beginnt OOP: Zum Exportieren muss Deine package von der Superklasse Exporter erben: require Exporter; und ist dann selbst ein Exporter mit @ISA = qw(Exporter);.

Cargo cult!

Schön dass Du hier bist.

4. Ja, die Exporter-Dokumentation ist noch voll von dem Vererbungs-Unsinn. Leider. Bug!

Zeit für neue Bücher meinerseits. Und ein neues Perl werde ich mir auch installieren. Und umdenken in manchen Sachen, dank Deiner Hilfe, ja freilich.

Btw., ich bin mittlerweile auch mit {RaiseError => 1} und dem Exception-Model in Perl schon viel weiter gekommen, auch dank Deiner Hinweise und eigener Erfahrung: Heute morgen hatte ich tatsächlich einen kleinen TippFehler, qw() anstelle qq() und damit ein ungültiges Statement, wo mir eine Abfrage DBI::errstr drei Zeilen weiter nüscht mehr nützte ;)

Ergo: Mögliche Exceptions sauber auffangen und alles wird gut.

Achja, nochwas zum Organisieren der Trenung von fetch* und Darstellung der Daten betrf. kleinerer Datenmengen im RAM, schöne Lösung mit einer Callbackfunktion:

  
		while( my $ref = $sth->fetchrow_arrayref){  
			$self->{CBK}($ref);		  
		}  

Hotti

[Alexander (HH)]

Moin Moin!

Achja, nochwas zum Organisieren der Trenung von fetch* und Darstellung der Daten betrf. kleinerer Datenmengen im RAM, schöne Lösung mit einer Callbackfunktion:

  while( my $ref = $sth->fetchrow_arrayref){  
  	$self->{CBK}($ref);		  
  }  

  
Den dezenten kleinen Hinweis unter [DBI/fetchrow_arrayref](http://search.cpan.org/~timb/DBI-1.616/DBI.pm#fetchrow_arrayref) hast Du gelesen, der eigentlich mindestens fett gesetzt werden sollte?  
  
"Note that the same array reference is returned for each fetch, so don't store the reference and then use it after a later fetch. Also, the elements of the array are also reused for each row, so take care if you want to take a reference to an element."  
  
Damit kann man sich WUNDERSCHÖNE Bugs bauen. Zum Beispiel, indem Dein Callback erst einmal nur `push @todo,$ref`{:.language-perl} macht. So lange Du nur eine Zeile aus der DB ziehst, merkst Du das nicht einmal.  
  
Alexander

-- 
Today I will gladly share my knowledge and experience, for there are no sweeter words than "I told you so".

[hotti]

hi,

"Note that the same array reference is returned for each fetch, so don't store the reference and then use it after a later fetch. Also, the elements of the array are also reused for each row, so take care if you want to take a reference to an element."

Is Bekannt ;)

Damit kann man sich WUNDERSCHÖNE Bugs bauen. Zum Beispiel, indem Dein Callback erst einmal nur push @todo,$ref macht. So lange Du nur eine Zeile aus der DB ziehst, merkst Du das nicht einmal.

Ja, so Mancher Einer muss das mindestens einmal gemacht haben:

  
my @names =qw(Otto Anna Emil Horst Alex);  
foreach my $n(@names){  
  $n = 'Hugo';  
}  

Und sich dann wundert, warum die später alle 'Hugo' heißen!?

Hotti

[hotti]

Moin,

wie lernen z.Z. absolute Basics in Perl und bei mir scheitert es schon bei einem Variablenaufruf eines anderen Packages.

#!perl -w

use strict;
package IDependencies;
my $requirementFulfilled;
package initialize;
###...##

>   
> Bis hier gelesen, kurze Erläuterung: jede Zeile  
  
Wenn Du mehrere packages in einer Datei definierst, könnte auch 'our' interessant sein:  
  
~~~perl
  
use strict;  
use warnings;  
  
package Foo;  
our $foo = 20;  
  
package Bar;  
my $bar = $foo;  
  
package main;  
print $foo; # 20  

perldoc -f out

Hotti

[Alexander (HH)]

Moin Moin!

Wenn Du mehrere packages in einer Datei definierst, könnte auch 'our' interessant sein:

Und vor allem sollte man die Packages in Blöcke packen, weil sonst einige Dinge durcheinander kommen können. Siehe z.B. http://www.perlmonks.org/index.pl?node_id=419327.

Code:

  
#!/usr/bin/perl  
  
{  
    package A;  
  
    ...  
    ...  
}  
  
{  
    package B;  
  
    ...  
    ...  
}  
  
A->foo(B->bar());  

Alexander

[hotti]

Moin Moin!

Wenn Du mehrere packages in einer Datei definierst, könnte auch 'our' interessant sein:

Und vor allem sollte man die Packages in Blöcke packen, weil sonst einige Dinge durcheinander kommen können. Siehe z.B. http://www.perlmonks.org/index.pl?node_id=419327.

Ja. Wie ich schon bei Stuppi schrieb: Wenn meine Bücher veraltet sind, heißt das noch lange nicht, dass ich nicht mehr Lesen kann ;)

Es kommt immer darauf an, in welcher kollegialen Umgebung Du landest. Teamarbeit kann zu sehr produktiven Resonanzen führen, wenn ein einheitlicher Stil vorherrscht und die Schnittstellen klar definiert sind.

Viele Grüße aus Rheinland-Pfalz/Rheinhessen,
Hotti

[Struppi]

wie lernen z.Z. absolute Basics in Perl und bei mir scheitert es schon bei einem Variablenaufruf eines anderen Packages.

Du solltest dir mal die Basics der Perldokumentation anschauen
http://perldoc.perl.org/perlboot.html
http://perldoc.perl.org/perltoot.html
http://perldoc.perl.org/perlbot.html

Dein Problem ist, dass du denkst eine package Variabel ist ein Member einer Klasse. Dem ist aber nicht so, viel mehr entspricht dein %hastable einer statischen Variabel, die in allen Instanzen identisch ist.

Ich will ja in meiner Main auf den Hash zugreifen und ihn ändern können. und im Prinzip etwas schreiben wie:

package main;

my $Method = new Method;
my $2Method = new Method;
my $combinatorics = new Combinatorics;
$combinatorics::%hashtable = ($Method=>$2Method)

>   
>   
> Falls es irgendjemandem helfen sollte mein Problem zu verstehen;  
> In C# würd ich,um das selbe zu realisieren, schreiben:  
>   
>   
> public class Combinatorics {  
>   
> Dictionary <initialize,initialize> hashtable = new Dictionary <initialize,initialize>();  
>   
> }  
> Method method = new Method();  
> Method 2method = new Method();  
> Combinatorics combinatorics = new Combinatorics();  
>   
>   
> combinatorics.hashtable.Add(method,2method)  
>   
  
  
In Perl (Version <6) gibt es keine Klassen in dem Sinne, wie es OOP Sprachen umsetzen. Der einfachste Weg dort ist es einen Hash mittels bless an ein package zu binden. Das bedeutet, dass %hashtable keine package sein darf, sondern eine Eigenschaft des gebundenen Hash. Was aber in deinem Grundgerüst etwas schwieriger ist, weil du eine Basisklasse definiert hast.  
  
~~~perl
package Combinatorics;  
use parent 'initialize'; # parent ist besser als base  
  
sub new {  
   my $self = shift->SUPER::new(@_);  
   $self->{hashtable} = {};  
   return $self;  
}  

Bei dem Rest deines Beispiel Codes erkenne ich nicht ganz, was du da machen willst. Wenn es nur um den Zugriff geht, sieht es so aus:

package main;  
  
my $Method = new Method;  
my $2Method = new Method;  
my $combinatorics = new Combinatorics;  
$combinatorics->{hashtable} = ($Method=>$2Method);  

Wobei das wenig Sinn macht, da du so dem Hash eine Liste mit einem Element zuweist (bei eingeschalteten Warnungen wird dir das so ausgegeben).

Auch ist es nicht schön, auf Attribut so zu zugreifen. Da Perl keine privaten Attribute kennt, sollte man sich darauf einigen auf diese möglichst nicht direkt zu zugreifen und das ganze über Memberfunktionen zu regeln.

Und um den Einwürfen unseres lieben Forumskollegen CPAN zuvor zu kommen. Perl 6 ist auf dem Weg und der Perlfachmann spricht mittlerweile von modern Perl, in diesem Kontext wird u.a. das Modul Moose für Objektorientierte Perlprogrammierung empfohlen.

Struppi.
Struppi.

[Alexander (HH)]

Moin Moin!

wie lernen z.Z. absolute Basics in Perl

Ganz offenbar ist der Lehrer nicht so ganz auf dem Laufenden. Indirect Object Syntax ist etwas, was man sich besser gar nicht mehr angewöhnt. Deswegen scheinst Du auch einige Verständnisprobleme zu haben.

und bei mir scheitert es schon bei einem Variablenaufruf eines anderen Packages.

Du redest von Variablen und Packages, kommst aber andererseits mit OOP-Konstrukten an. Perl kann beides, aber es gibt dabei feine Unterschiede. Was willst Du?

#!perl -w

use strict;
package IDependencies;
my $requirementFulfilled;
package initialize;
sub new (){
my $self=shift;
my $newInst={};
bless($newInst,$self);
}

Da fehlt für meinen Geschmack ein return. Implizit gibt Perl den Wert des letzten Statements zurück, das ist bless, das wiederum gibt seinen ersten Parameter zurück.

Außerdem ist $self zwar kein reserviertes Wort wie z.B. print, aber es gibt eine sehr weit verbreitete Konvention, $self so zu benutzen wie this in Javascript und Java, nämlich als Objekt-Instanz.

In dieser Routine ist $self aber der Klassenname, nicht die Objekt-Instanz. Die steht in $newInst.

Besser:

  
sub new  
{  
    my $class=shift;  
    my $self=bless {},$class;  
    return $self;  
}  

Wenn Du neue Objekt aus bestehenden generieren willst, der Construktor also auch als Instanz-Methode aufrufbar sein soll, sieht das so aus:

  
sub new  
{  
    my $proto=shift;  
    my $class=ref($proto)||$proto;  
    my $self=bless {},$class;  
    return $self;  
}  

package Method;
use base 'initialize';
my $name;
sub IsFullfilled()
{
print $requirementFulfilled = 0;

}

Was geht denn hier ab?

Was macht $name da?

Warum liefert eine Funktion, von der man aufgrund ihres Namens annehmen sollte, dass sie einen boolschen Wert zurückliefert, nichts zurück? (Technisch gesehen liefert sie zurück, ob print funktioniert hat oder nicht.)

Und warum setzt die Funktion als Seiteneffekt die Variable $requirementFulfilled auf 0?

package Combinatorics;
use base 'initialize';

use base macht viel Theater um Dinge, die kaum jemand benutzt. use parent ist mit gleicher Syntax deutlich schlanker.

my %hashtable;

package main;

my $Method = new Method ->IsFullfilled();

Indirect Object Syntax. Pfui!

Du meinst:

my $Method=Method->new()->IsFullfilled();

Das ist mein bisheriger Code.

Durchaus verbesserungsfähig, siehe oben.

perlobj, perltoot, perlboot und perltooc hast Du gelesen und verstanden?

Am Ende soll in einer Hash-Table als Key die Instanz einer Method stehen und als Value entweder eine Instanz einer anderen Method, nichts oder aber erneut ein Hash-Table in dem widerrum das selbe stehen kann.

Nun hab ich ein gewaltiges Problem im package main auf die Variable von Combinatorics zuzugreifen und Einträge zu ändern.

Nochmal: Willst Du OOP oder willst Du prozedural arbeiten?

In reinem OOP solltest Du in den einzelnen Klassen überhaupt keine Variablen rumfliegen haben, sondern mit Objekt-Attributen arbeiten.

Wenn Du kein OOP haben willst, kannst Du aus Packages heraus Variablen exportieren, siehe Exporter. Die am meisten überlesene Stelle in der Exporter-Dokumentation ist leider Exporting without inheriting from Exporter, denn das Erben vom Exporter hat viele unerwünschte Seiteneffekte.

Notwendiger Code in Packages, die etwas exportieren sollen:

  
use Exporter qw( import );  
our @EXPORT_OK=( ... );  

(Kein @ISA, kein require. Das ist prähistorischer Cargo Cult, der in neuem Code nichts mehr verloren hat.)

Testweise hab ich das Script erweitert:

package combinatorics;
%hashtable = (Teststring=>"Teststring",Teststring2 =>"Teststring2");
print "$hashtable{'Teststring'}Teststring  $hashtable{'Teststring2'} Teststring2";

>   
> Funktioniert auch tadellos,  
  
Glaub ich bei aktivem strict nicht so ganz ...  
  

> aber:  
>   
> Ich will ja in meiner Main auf den Hash zugreifen und ihn ändern können.  
  
Warum fummelst Du dann mit OOP herum?  
  

> und im Prinzip etwas schreiben wie:  
>   
> package main;  
>   
> my $Method = new Method;  
> my $2Method = new Method;  
  
$2Method ist kein gültiger Name.  
  
Und gewöhn Dir die Indirect Object Notation besser gleich wieder ab, auch wenn sie hübsch nach C++/C#/Java aussieht, macht sie Perl mehr Arbeit und Dir auf Dauer nur Ärger.  
  
my $Method=Method->new();  
my $Method2=Method->new();  
  

> my $combinatorics = new Combinatorics;  
  
$combinatorics ist eine Instanz von Combinatorics.  
  

> $combinatorics::%hashtable = ($Method=>$2Method)  
  
Was soll das werden?  
  
Wenn Du auf die (per our oder use vars deklarierte) Variable %hashtable im Package Combinatorics zugreifen willst, geht das so:  
  
`%Combinatorics::hashtable=(...)`{:.language-perl}  
  
Das widerspricht aber jedem Ansatz von OOP und wird Dir auf lange Sicht nur Ärger machen.  
  
  
Wenn Du einen Accessor stricken willst, pack den ins Package Combinatorics und lasse den auf die Variable zugreifen, die entspricht dann am ehesten einem Klassen-Attribut.  
  
  
~~~perl
  
package Combinatorics;  
  
use strict;  
use warnings;  
  
my %hashtable;  
  
# ...  
  
sub set_hashtable  
{  
    my $self=shift;  
    %hashtable=(@_);  
    return $self;  
}  
  
# ...  

Falls es irgendjemandem helfen sollte mein Problem zu verstehen;
In C# würd ich,um das selbe zu realisieren, schreiben:

public class Combinatorics {

Dictionary <initialize,initialize> hashtable = new Dictionary <initialize,initialize>();

}
Method method = new Method();
Method 2method = new Method();

Ich glaube nicht, dass in C# 2method ein gültiger Name ist.

Combinatorics combinatorics = new Combinatorics();

combinatorics.hashtable.Add(method,2method)

Hast Du mal versucht, das zu compilieren?

Alexander

[Karakash]

Okay, ich will euch erklären wofür das Programm gut ist:

Die Klasse Method enthält einen Namen sowie einen boolean der angibt, ob eine Methode der Klasse ausgeführt wurde oder nicht.
In meiner Main hab ich eine Hash in welcher als Key immer eine Instanz von Method liegt, und als Value eine Instanz einer Method oder erneut eine Hashtable.

Der Value der Hashtable gibt dabei logisch an, welche Abhängigkeiten die Instanz(key) besitzt und ob diese true(also erfüllt) oder false(nicht erfüllt) sind.

Somit kommen wir zu dem Schluss, dass wir folgendes brauchen:

  
package Method {  
  
my name;  
my Isfulfilled;  
sub irgendeinemethode()  
{  
  
}  
}  
  
package main;  
  
my %hashtable;  
  
my $method1= Method -> new();  
my $method2= Method -> new();  
my $method3= Method ->new();  
my $method4= Method ->new();  
my %hashtable2;  
%hashtable={$method1=>$method2,$method2=>$hashtable2);  
%hashtable2={method3=>$method4,$method4=>$method1};

Oder in Klartext:

Eine Klasse welche eine Variable für einen Bool und einen String hat.

Mehrere Instanzen einer Klasse(Method).

Eine Hashtable in welche alle Instanzen von Method reinkommen bzw weitere Hashtables für die Baumhirarchie.

»»»» $combinatorics::%hashtable = ($Method=>$2Method)

»»Was soll das werden?

»»Wenn Du auf die (per our oder use vars deklarierte) Variable %hashtable im Package Combinatorics zugreifen willst, geht das so:

Wir haben wohl ein etwas größeres Missverständnis:
Mit dem Code:

my $combinatorics = Combinatorics ->new();
hält für mich die Variable $combinatorics die Instanz des Packages Combinatorics.
somit hält

my $method1= Method -> new();

$method1 die Instanz von Method.
mit $method1::name || $method1::IsFulfilled  möchte ich auf die Werte meiner Instanz zurückgreifen.

Ergo soll mein Code für

print $method1::name = "method1";
method1 zurückliefern
während print $method2::name = "method2";
method2 zurückliefern soll.

[Struppi]

Okay, ich will euch erklären wofür das Programm gut ist:

Die Klasse Method enthält einen Namen sowie einen boolean der angibt, ob eine Methode der Klasse ausgeführt wurde oder nicht.

Wie gesagt, du definierst statische Variabeln, die in allen Instanzen gleich sind. Ich bezweifle, dass es das ist was du möchtest.

In meiner Main hab ich eine Hash in welcher als Key immer eine Instanz von Method liegt, und als Value eine Instanz einer Method oder erneut eine Hashtable.

Der Schlüssel eines Hash ist immer eine Zeichenkette, warum willst du dort eine Instanz abspeichern?

Der Ansatz ist reichlich krude und klingt nicht nach OOP.

Somit kommen wir zu dem Schluss, dass wir folgendes brauchen:
my %hashtable;

my $method1= Method -> new();
my $method2= Method -> new();
my $method3= Method ->new();
my $method4= Method ->new();
my %hashtable2;
%hashtable={$method1=>$method2,$method2=>$hashtable2);
%hashtable2={method3=>$method4,$method4=>$method1};[/code]

Ich komme mit deinen Beispielcode nicht klar. Der Code ist nicht lauffähig.

Welchen Zweck möchtest du mit dem Hash erfüllen? Darüber hinaus solltest du dir die Links die ich und Alexander dir gezeigt haben zu Gemüte führen, damit würdest du schon einmal einen tieferen Einblick bekommen.

Oder in Klartext:

Eine Klasse welche eine Variable für einen Bool und einen String hat.

Es gibt keinen Klassen und was du als "hat eine Variabel" bezeichnest, sind statische Variabeln, die in allen Instanzen identisch sind.

Wir haben wohl ein etwas größeres Missverständnis:
Mit dem Code:

my $combinatorics = Combinatorics ->new();
hält für mich die Variable $combinatorics die Instanz des Packages Combinatorics.

Das ist in dem Fall richtig.

somit hält

my $method1= Method -> new();

$method1 die Instanz von Method.

mit $method1::name || $method1::IsFulfilled  möchte ich auf die Werte meiner Instanz zurückgreifen.

Das sind nicht die Werte der Instanz, sondern des package - das ist ein grosser Unterschied.

Ergo soll mein Code für

print $method1::name = "method1";
method1 zurückliefern
während print $method2::name = "method2";
method2 zurückliefern soll.

Dann musst du es so machen, wie ich es dir schon gezeigt habe oder du schaust dir noch mal die Dokumentation an, dort wird das sehr gut und ausführlich beschrieben.

Struppi.

[Karakash]

Ich glaube es gibt eine große Diskrepanz zwischen sehr gut und ausführlich in eurer und meiner Sichtweise.

Ich hab schon sehr große Probleme euch zu folgen, deutschen und englischen Tutorials zu diesem Thema, und erst Recht der Dokumentation.

Und anbei sei angemerkt:

natürlich ist mein Code nicht lauffähig, er ist auch lediglich ein Pseudocode - wenn ers wäre, hät ich ja keine Probleme :)

»»Wie gesagt, du definierst statische Variabeln, die in allen Instanzen gleich sind. Ich bezweifle, dass es das ist was du möchtest.

Wie geschrieben ist das eine Erkentniss, welche ihr mir zum Glück dargelegt habt - ergo suche ich nun einen Weg die Variable so zu definieren, dass sie eben nicht statisch ist

»»Der Schlüssel eines Hash ist immer eine Zeichenkette, warum willst du dort eine Instanz abspeichern?

Ich will ja nicht die Instanz an sich, sondern die Referenz auf die Instanz abspeichern.
Somit kann ich über die Abfrage des Keys auf die Werte der Instanz kommen und muss nicht umständlich die Zeichenkette nehmen und nach einer Instanz suchen die genauso heißt.
Die Instanznamen werden schließlich generiert, und nicht per Hand angelegt.

»»Welchen Zweck möchtest du mit dem Hash erfüllen?
Der Hash wird mit einem foreach durchlaufen und für jedes Value wird überprüft, ob der boolean true oder false ergibt. Erscheint ein false wird der Hash als "failed" deklariert. Wie lang der Hash wird, wie verschachtelt er ist ist vorher nicht bekannt und wird zur Laufzeit erst festgelegt.
Was im Endeffekt zu solchen Konstruktionen führt:
Hash[key,hash[key,hash[key,value,key,value],key,value]]

Subnote: Mit einigen Hints die von euch immer mal wieder gegeben wurde, komm ich auch regelmäßig zu Compilerfehler die ich nichtmal im Ansatz verstehe und ersteinmal googlen muss - eben weil ein fundiertes Wissen zu Perl fehlt - das Programm dennoch geschrieben werden muss und somit auch die Zeit relativ eng bemessen um alles von vorne aufzurollen.
Z.b. das parent statt 'base' liefert bereits einen compilefehler.

Nungut, ich werde mich nochmal an die Dokumentation setzen und gucken, ob ich etwas brauchbares finde.

Danke für die Hilfe

[Struppi]

Und anbei sei angemerkt:

natürlich ist mein Code nicht lauffähig, er ist auch lediglich ein Pseudocode - wenn ers wäre, hät ich ja keine Probleme :)

Leider ist es aber auch sehr schwer aus diesem Code zu erkennen, was du eigentlich willst. Zumal, so wie du dir dein momentanes Ziel vorstellst, ist es in Perl falsch.

»»Wie gesagt, du definierst statische Variabeln, die in allen Instanzen gleich sind. Ich bezweifle, dass es das ist was du möchtest.

Wie geschrieben ist das eine Erkentniss, welche ihr mir zum Glück dargelegt habt - ergo suche ich nun einen Weg die Variable so zu definieren, dass sie eben nicht statisch ist

Steht in der Doku und hatte ich auch in meiner ersten Antwort ansatzweise schon gezeigt.

»»Der Schlüssel eines Hash ist immer eine Zeichenkette, warum willst du dort eine Instanz abspeichern?

Ich will ja nicht die Instanz an sich, sondern die Referenz auf die Instanz abspeichern.

auch das geht nicht, da der Schlüssel eine Zeichenkette ist, wandelt Perl die Referenz intern in eine Zeichenkette um. Ich frage mich warum du glaubst das wäre nützlich?

Somit kann ich über die Abfrage des Keys auf die Werte der Instanz kommen und muss nicht umständlich die Zeichenkette nehmen und nach einer Instanz suchen die genauso heißt.

Das verstehe ich nicht, ich vermute du hast einen Denkfehler in deinen überlegungen.

»»Welchen Zweck möchtest du mit dem Hash erfüllen?
Der Hash wird mit einem foreach durchlaufen und für jedes Value wird überprüft, ob der boolean true oder false ergibt. Erscheint ein false wird der Hash als "failed" deklariert. Wie lang der Hash wird, wie verschachtelt er ist ist vorher nicht bekannt und wird zur Laufzeit erst festgelegt.

Das erklärt nicht den Zweck, nur das was du möchtest. Aber was ist der Sinn dieser Sache. willst du rausfinden ob eine Instanz erzeugt wurde? Oder willst du den konkreten Wert einer Instanz? Für beide Fälle brauchst du kein Hash, da reicht z.b. auch ein Array deiner Instanzen.

Was im Endeffekt zu solchen Konstruktionen führt:
Hash[key,hash[key,hash[key,value,key,value],key,value]]

Tut mir leid, das verwirrt mich jetzt mehr als das es erklärt, warum du so umständlich auf die Instanzen zugreifen willst.

Z.b. das parent statt 'base' liefert bereits einen compilefehler.

Dann ist dein Perl zu alt. Aber parent nachzuinstallieren ist einfach.

Übrigens das A&O von Perl: wie verwendest du Module und wie installiert man diese? Ohne Module ist Perl nur ein Bruchteil Wert.

Struppi.

[Karakash]

Sprich:

  
package Hashtable;  
sub new() {  
my %hashtable;  
my $self=shift;  
my $newInst={};  
bless($newInst,$self);  
}  
  
package main;  
  
my $Hashtable = Hashtable ->new();  
  
$Hashtable::hashtable = {teststring=>"teststring",teststring2=>"teststring2"}  
my $Hashtable2 = Hashtable ->new();  
  
$Hashtable2::hashtable = {teststring=>"teststring3",teststring2=>"teststring4"}  
  
foreach my $key (keys my %hash=$Hashtable::hashtable)  
{  
  
print $key;  
}  
foreach my $key (keys my %hash=$Hashtable2::hashtable)  
{  
  
print $key;  
}  
  
müsste teststringteststring2 und teststring3teststring4 ausspucken?  

[Struppi]

müsste teststringteststring2 und teststring3teststring4 ausspucken?

Nein.

Wie gesagt, ich finde den Ansatz merkwürdig und er macht nicht wirklich Sinn.

Aber du hast auch massive Probleme mit der Perlsyntax. Dein Beispiel (was ich wie gesagt für nicht sauber halte) sähe so aus:

#!/usr/bin/perl -w  
use strict;  
  
package Hashtable;  
  
sub new() {  
	return bless { hashtable => {} }, shift;  
}  
  
package main;  
  
my $Hashtable = Hashtable ->new();  
my $Hashtable2 = Hashtable ->new();  
  
$Hashtable->{hashtable} = {teststring=>"teststring",teststring2=>"teststring2"};  
$Hashtable2->{hashtable} = {teststring=>"teststring3",teststring2=>"teststring4"};  
  
foreach my $key (keys %{$Hashtable->{hashtable}}) {  
	print $key;  
}  
foreach my $key (keys %{$Hashtable2->{hashtable}}) {  
	print $key;  
}  

Damit hast du dann häßliche Dereferenzierungen.

Struppi.