GoTo: Methode eines Objekts (Referenz) aufrufen

Hallo,

ich habe ein kleines Programm geschrieben, welches mir alle Kombinationen ohne Zurücklegen ausgibt mit 1-X Stelen, sprich bei den Zahlen 1-3 bekomme ich folgendes Ergebnis.

1
2
3
12
13
21
23
31
32
123
132
213
231
312
321

Soweit so gut, das klappt alles doch möchte ich dort jetzt nicht simple Zahlen miteinander kombinieren, sondern Objekte.

Hier erstmal mein Code:

InitializeObjekt.pm

  
package initializeObject;  
sub new  
{  
  
	my ($class,$name) = @_;  
	my $self = {Name=>$name,IsFulfilled=>$class->default_IsFulfilled,IsUsed=>$class->default_IsUsed};  
	bless $self,ref($class) || $class;  
	  
}  
  
  
sub default_IsFulfilled{0};  
  
sub return_IsFulfilled  
{  
    $_[0]->{IsFulfilled};  
}  
  
sub set_IsFulfilled  
{  
    $_[0]->{IsFulfilled} = $_[1];  
}  
  
  
sub default_IsUsed{0};  
  
sub set_IsUsed  
{  
    $_[0]->{IsUsed}=$_[1];  
  
}  
  
sub return_IsUsed  
{  
    $_[0]->{IsUsed};  
}  
  
  
sub getName  
{  
	return $_[1]->{Name};  
}  
  
1;  

Hier das eigentliche Programm:

  
#!perl -w  
  
use strict;  
use initializeObject;  
  
my $actualLength;  
my $locations = 3;  
my %methodList = (1 => (initializeObject->new("method1")), 2 => (initializeObject->new("method2")),  
3 => (initializeObject->new("method3")), 4 => (initializeObject->new("method4")),  
5 => (initializeObject->new("method5")), 6 => (initializeObject->new("method6")),  
7 => (initializeObject->new("method7")), 8 => (initializeObject->new("method8")));  
my $combination = "";  
my $count = 0;  
my @Combination;  
  
  
sub kombinieren  
{  
	my $stellen = shift;  
  
  
	if ($stellen <= 1)  
	{  
		foreach my $actualMethod (values %methodList)  
		{  
			my $used = 0;  
			my $actualMethodName = $$actualMethod{Name};  
  
			foreach my $k (@Combination)  
			{  
  
				if ($k eq $actualMethodName)  
				{  
					$used = 1;  
				}  
			}  
			if ($used == 0)  
			{  
				$Combination[$stellen - 1] = $actualMethodName;  
				&CreateTest();  
				$count++;  
				$Combination[$stellen - 1] = "";  
			}  
		}  
	}  
	else  
	{  
		foreach my $actualMethod (values %methodList)  
		{  
			my $used = 0;  
			my $actualMethodName = $$actualMethod{Name};  
  
  
  
			foreach my $k (@Combination)  
			{  
				if ($k eq $actualMethodName)  
				{  
					$used = 1;  
				}  
			}  
			if ($used == 0)  
			{  
				$Combination[$stellen - 1] = $$actualMethod{Name};  
				kombinieren($stellen - 1);  
				$Combination[$stellen - 1] = "";  
			}  
		}  
	}	  
}  
  
  
sub CreateTest  
{  
	my $wort = join("", @Combination);  
	print $wort."\n";  
}  
  
  
for ($actualLength = 1; $actualLength <= $locations; $actualLength++)  
{  
	&kombinieren($actualLength);  
}  
print "Gesamt: $count Kombinationen"  

Jetzt zu meinem Problem:

Anstatt $$actualMethod{Name} in das Array zu geben würde ich gerne eine Referenz auf das entsprechende Objekt aus der %methodList in das Array geben. Später möchte ich dann via foreach Schleife auf diese Referenz zugreifen und eine Methode, welche das Objekt auf das ich die Referenz haben, ausführen.

Dies soll dazu dienen, um die Kombinationen anhand von Abhängigkeiten zu erstellen. So sollen später manche Objekte nur dann in die Kombination aufgenommen werden, wenn vorher ein bestimmtes anderes Objekt schon verwendet wurde.

Ich hoffe ich habe mich einigermaßen verständlich ausgedrückt :)

Und schon einmal Danke für eure Antworten.

  1. hi,

    Anstatt $$actualMethod{Name} in das Array zu geben würde ich gerne eine Referenz auf das entsprechende Objekt aus der %methodList in das Array geben.

    Nicht machen, geht schief und ist bereits in der Entstehungsphase unüberschaubar.

    Später möchte ich dann via foreach Schleife auf diese Referenz zugreifen und eine Methode, welche das Objekt auf das ich die Referenz haben, ausführen.

    Nutze die Vererbung. Objekte einer abgeleiteten Klasse erben z.B. über @ISA von der Superklasse die Methoden. Zum Erben der Attribute ist ein kleiner Trick notwendig, aber danach wurde nicht gefragt ;)

    Dies soll dazu dienen, um die Kombinationen anhand von Abhängigkeiten zu erstellen. So sollen später manche Objekte nur dann in die Kombination aufgenommen werden, wenn vorher ein bestimmtes anderes Objekt schon verwendet wurde.

    Wieviele Objekte hast du denn in Deiner main rumschwirren? Gerade dann, wenn Du mehr als eins brauchst, sollte das überschaubar bleiben. Aber ab dem Dritten würde ich mir überlegen, ob das einen Sinn ergibt. Selbst die Vererbung zur Laufzeit ist nicht ganz 'Ohne' und chaotisch kanns werden, wenn zur Laufzeit zu Objekten Attribute und Methoden hinzukommen, sowas besser nicht machen, sondern vielmehr bereits im Konstruktor _alle_ Attribute wenigstens als { FOO => undef, } notieren, dann behältst Du auch die Übersicht (die ich bei Deinem Code nicht erkenne).

    Hotti