Problem mit Gültigkeitsbereich einer Funktion

[_crypto_]

Also die Struktur läßt sich recht einfach beschreiben:

std.datatypes
|
|- vector implements IIterator
    |- myNamespace function get_reference():Array

std.utils
|
|- iterator
|  |- public function get value():*
|
|- IIterator

Was ich damit anfangen möchte:
Der Iterator, der schließlich ein Zeiger ist, die es in Flash ja so nicht gibt, soll immer auf das aktuelle Element zeigen, was sich im Vektor, bspw.
befindet.

Wenn ich im Vektor was ändere, muss der Iterator auch auf das geänderte
Element zeigen, und nicht einen statischen Array auslesen!!

public function iterator( reference:Array )
{
    this.data = reference;
} 

Ist also nicht zu gerbauchen. Ich will aber den Iterator auch nicht in das Package: datatypes mit einbringen, nur weil ich dann internal nutzen kann. Denn ein Iterator ist kein eigener Datentyp in dem Sinne.

Also was tun? Eigene Namespaces ...

// vector
myNamespace function get_reference():Array
{
    return ... // usw.
}
 
// iterator
public function get value():*
{
    use namespace myNamespace;
 
    // liest den aktuellen array aus
    data = scope.get_reference();
} 

Problem:
Ich möchte, dass scope eigentlich nicht den typ bestimmt. Wieso? Weil ein Iterator nicht nur für Vektoren geschaffen ist

Also dachte ich: Ja nehmen wir doch IIterator dann ist es perfekt
gelöst ... aber Funktionen in Schnittstellen müssen ... richtig public sein -.-

Das einzigste was ich machen könnte: Eine abstrakte Klasse anstelle der Schnittstelle. Das klapt dann zwar alles, sieht aber unsauber aus. Die Lösung wär so perfekt OOP gewesen, wenn Schnittstellen mal nicht so zickig wären

internal wäre ja eigentlich perfekt, denn der Benutzer selber, sollte nicht auf diese Funktion zugreifen dürfen,
das mit Namespaces einzuschränken ist aber auch ok so, nur am besten wäre ein eigenes internal, dass ich so definieren
kann wie ich will, und in einem interface

[Omega Psi]

Sorry, aber was willst du machen? Ich verstehe das Problem nicht. Du willst einen simplen Iterator implementieren und was noch?

[_crypto_]

ich könnte ihn einfach in den ordner packen: datatypes
so dann hab ich eine methode die ich mit "internal" deklariere,
damit man von außen ncihts aufrufen kann:

was diese methode macht: sie holt sich den array, also die daten
der referenz, auf den der iterator zeigt.

der iterator muss immer die aktuellen daten haben, da es in flash
ja eben keine zeiger gibt, sonst könnt ich einfach auf die adresse
zeigen

deswegen versuch ich mir damit zu helfen. so wie es oben steht klapt es ja,
aber ich will den iterator eben nicht in das gleiche packet setzen.

anders geht es eben nicht, also soweit ich es kann, deswegen frag ich ja
weil ich es gerne mit ner schnittstelle und nem eigenen namespace machen möchte.

edit:
ach ja dann trat noch das problem auf mit der abstrakten klasse,
wenn ich anstelle des interfaces eine klasse nehme, kann ich die funktionen auch mit meinem eigenen namespace
verknüpfen, aber was sagt mir der compiler dann:

mit "override" gekenzeichnete methoden müssen ... bla bla bla
dabei stimmt alles ... aber nein wenn ich namespaces benutze kann ich NICHT andere wie public oder so zusätzlich verwenden
was is das denn alles für schrott

[Omega Psi]

Hm, verstehe ich immer noch nicht. Wenn du dem Iterator eine Refrenz mitgibst, ist doch alles in Butter? Damit zeigst du doch immer auf genau das Objekt, über das du den Iterator laufen lassen möchtest.

Die Referenz zeigt ja auf einen eindeutigen Adressbereich, nur hast du keine Arithmetik.

Mein Tipp: ein Interface IIterator, eine Factory, die einen konkreten Iterator erzeugt und eine konkrete Klasse, die das Interface implementiert und über das Array iteriert. Die Implementiertung kriegt eine Refrenz auf das Array und alles ist gut.

[_crypto_]

nene so gehts ja nicht ^^
wenn ich dem iterator einen array übergebe dann passiert ja das:

function doSomething( reference:Array ):void
{
	reference = [];
	trace( reference );
}

var arr:Array = [0,0,0,1,1,1,1];
doSoemthing( arr ); // gibt leer aus
trace( arr ); // 0,0,0,1,1,1,1

das is ja eben das was man mit zeigrn umgeht, bzw anders macht,
man kann damit ja das original ändern und flash kopiert immer nur.

deswegen wollte ich dem iterator eine referenz zu seiner klasse, die er durchiteriert geben und damit kann er sich den Array krallen über eine methode.

nur das einzigste problem, diese methode sollte geschützt sein, das nur der iterator dadrauf zugreifen kann. muss ja so sein wenn ich die funktion von zeigern nachbauen möchte.

[Omega Psi]

Das ist ja auch falsch:

package {
  public class Iterator implements IIterator {
 
    private var _array:Array;
    private var _index:int;
 
    public function Iterator(array:Array) {
      if (array == null) {
        throw new ArgumentError("Param must not be null")
      }
      this._array = array;
      this._index = 0;
    }
 
    public function hasNext():Boolean {
      returun (this._index < this._array.length-1)
    }
    
    public function next():Object {
      return this._array[this._index++];
    }
  }
} 

[_crypto_]

ja das ist es doch!

ein iterator MUSS ein zeiger sein, es gibt sie aber nicht in flash und
deswegen will ich das der iterator so aussieht:

package
{
    public interface IIterator
    {
        function get_data():Array;
        function begin():Iterator
        function end():ReverseIterator;
    }
}
 
package
{
    public class Iterator
    {
        private var _scope:IIterator;
        private var _index:int;
 
        public function Iterator( SCOPE:IIterator )
        {
            if ( SCOPE == null ) {
               throw new ArgumentError("Param must not be null")
            }
            this._scope = SCOPE;
            this._index = 0;
        }
 
        public function hasNext():Boolean {
            returun (this._index < this._array.length-1)
        }
    
        public function next():Object {
           var data:Array = this._scope.get_data();
           return data[this._index++];
       }
   }
} 

denn wenn ich doch zur laufzeit den speicher meines vektors als
beispiel ändere, dann bleibt doch die adresse dahin gleich, und wenn
ich das dann anders implementiere ist der iterator doch fürn arsch

so wie oben solls, bzw. siehts aus, nur dieses "get_data()"
das wollte ich möglichst nur aufrufbar für den iterator halten.

999 beiträge

[Omega Psi]

Wofür willst du denn den Iterator nutzen? Den holt man sich doch nur mal eben in Schleifen. Soll das eine Datenstruktur sein, die du komplett drurch die Applikation schleifst? Das für sich genommen ist nicht klug.

[_crypto_]

ich glaube dann hast du vllt nicht genau verstanden warum es
iteratoren gibt (vorsichtig ausgedrückt)

wenn man ihn nur für schleifen nutzt dann könnte man ihn gleich weg
lassen

Iteratoren sind eine Art intelligente Zeiger, mit deren Hilfe über die Elemente eines Containers iteriert sowie auf einzelne Elemente des Containers zugegriffen werden kann.

das wäre wenn man ihn einfach so implementiert wir du meintest.

Die Iteratoren bilden ein zentrales und wichtiges Konzept für die Container. Bezogen auf ihre Aufgabe sind die Iteratoren reine Zugriffsobjekte. Sie entkoppeln die Algorithmen von den Containern, so dass diese typenunabhängig werden.

das ist punkt 2. und da ich grad an ner menge von algorithmen arbeite ist das ein riesen vorteil.
überleg doch mal du möchtest alle elemente inerhalb eines containers in einen anderen kopieren, aber! und das ist wichtig der tyxp der container soll uns nicht interessieren. Anstatt für jede art von container eine funktion zu haben gibst du einfach an:

function accumulate( start:Iterator, end:ReverseIterator, dest:IIterator ):Iterator
{
    for( start; Iterator.notEqual( start, end ); )
    {
        dest.erase( start.position );
        dest.insert( start.position, 1, start.next() );
    }	
    return dest.begin();
}

das ist es ja was ihn so nützlich macht
und da ich genau nach dem schema aufbaue brauch ich auch eigentlich
einen zeiger, da es die nicht gibt muss ich halt dem iterator immer die neuen daten geben damit das geht.

ansonsten ich habs jetz ersmal hinbekommen mit dem namespace.

[Omega Psi]

Ich kenne Iteratoren in der Tat nur als Möglichkeit über Collections zu iterieren. ich habe bis jetzt um beispiel auch noch nie eine insert() Methode bei einem Iterator gesehen.

[_crypto_]

ne sry das interace sollte eigentlich anders sein
denk dirf das als IContainer oder AbstractContainer,

aber du verstehst den sinn? das man mit ihnen typenunabhängige
algorithmen schreiben kann, ein klarer vorteil da es in Flash keine
templates und überladene funktionen gibt

[rendner[i]]

Normalerweise holt man sich diesen immer wieder aktuell wenn man über die Struktur läuft und nicht einmal initial, wie du es anscheinend gerne hättest.
Zumindest würde ich dies so handhaben.

Dein eigentliches Problem verstehe ich aber ehrlich gesagt auch nicht.

[Omega Psi]

Ja, aber ich sehe nicht den Sinn in typunabhängigen Algorithmen, denn du bekommst ja nur Objects -> das heisst du weisst gar nicht, was im iterator steckt, was ja auch Sinn der Sache ist.

[rendner[i]]

@_crypto_:

Vielleicht kannst du hier mal gucken, ob dich das befriedigt: http://lab.polygonal.de/ds/

[_crypto_]

doch es macht z.b. sinn. man benutzt es z.b. bei der for_each schleife
im engeren sinne:

// neuen vektor vom typ int
var v1:vector = new vector( int );
for( var i:int = 0; i < 5; i++ ) {
    v1.push_back(i);
}
// v1: 0,1,2,3,4
 
// neuer vektor vom typ String mit der Länge 5,
// jedes Elment ist "C"
var v2:vector = new vector( String, 5, "C" );
var itr:iterator = v1.begin();
 
// mehr speicherplatz reservieren
v2.rserve( 5 );
while( itr.hasNext() ) {
    // v1 in v2 hinzufügen
    v2.push_back( itr.next() );
}
 
itr = for_each( v2.begin(), v2.end() );
while( itr.hasNext() ) {
    trace( itr.next() );
    // C,C,C,C,C,0,1,2,3,4
} 

also flasgh bietet sowas schon an aber hir zeigt sich das,
anstatt mehrere funktionen wie for_each für einen Array
dann für ein Objekt und dann noch für nen String zu machen,
dient der iterator dafür einfach jede art von "container" durchzuiterieren
und man brauch nur 1 funktion, denn alle besitzen einen iterator und
damit erspart man sich doch einiges