iterator problemchen

Meep Meep

hola leute

hab mir einen container gebastelt und wollte nun dafuer nen interator bereitstellen.

class iterator
      {
         private:
            object *pointer;

         public:
            inline iterator(void);
            inline iterator(const TxlArray<object> &t_array);
            inline iterator(const object *t_data);
            inline ~iterator(void);

            inline object& operator*(void);
            inline object* operator++(void);
            inline object* operator++(int x);
            inline object* operator--(void);
            inline object* operator--(int x);
      };

den hab ich im publicbereich meines containers definiert.
im container hab ich noch die funktion Delete(object *t_pos);
nun kann ich aber nicht, wie bei nem vector meinen iterator einsetzen, damit die funktion die adresse des zu loeschenden objects kennt.
wie fehlt mir da bei dem iterator damit das funktioniert ?

cermy

Meep Meep

volkard

entweder muss der iterator nen zeiger auf den container halten (lahm).

oder zu verzichtest auf Delete(), so macht's die stl.

finix

Meep Meep schrieb:

class iterator
{
// ...
  inline object* operator++(void);
  inline object* operator++(int x);
  inline object* operator--(void);
  inline object* operator--(int x);
};

Sicher dass das so sein soll?

Meep Meep

re

inwiefern verzichtetdie stl auf Delete? die hat ja auch das Erase. ich habs halt anders benannt. und bei erase kann man ganz normal den iterator der funktion uebergeben. also muss der iterator nach aussenhin wie ein pointer des datentyps des vectors aussehen. wie machen die das ? oder hab ich da was falsch verstanden.

@finix: ja bin ich. wieso ? etwas daran falsch ?

Meep Meep

finix

Meep Meep schrieb:

@finix: ja bin ich. wieso ? etwas daran falsch ?

Versuch's mal so:

class iterator
{
// ...
  inline iterator& operator++();
  inline iterator operator++(int x);
  inline iterator& operator--();
  inline iterator operator--(int x);
};

edit:
Zu deinem eigentlichen Problem - meinst du nicht auch dass es darauf ankommt wie dein container konkret aussieht?

Meep Meep

warum soll ich einen iterator zurueck geben ? ich muss doch einen pointer auf den datentyp zurueckgegeben der im container liegt. denk ich mir mal.

ich kann auch einen vector<object>::iterator an meinen container anwenden. funktioniert. und nach dem ich meinem container object*pointer uebergebe, muss also der iterator nach aussenhin wie ein object*pointer aussehen. da setzt nun mein bissl hirn aus. ich versteh einfach nicht, wie das funktioniert.

Meep Meep

finix

Meep Meep schrieb:

warum soll ich einen iterator zurueck geben ? ich muss doch einen pointer auf den datentyp zurueckgegeben der im container liegt. denk ich mir mal.

Weil weder ein pre- noch ein postfix-[increment|decrement] dereferenziert.

Zum Problem: es kommt trotzdem darauf an was für eine Art container du hast.
Zur not auch einfach was in dieser Art:

iterator Delete(iterator iter)
{
  Delete(*iter);
  return ++iter; // hier faengt's schon an - ist iter noch zu gebrauchen?
}

Meep Meep

also irgendwie steh ich grad voll am schlauch.
machen wirs mal anders, vielleicht versteh ich es dann besser.
gegeben eine moechtegern-vector klasse:

template <class object>
class moechtegernvector
{
   private:
      object *data;
      unsigned int size;   

   public:
      moechtegernvector(unsigned int t_size) : size(t_size)
      {
         data = new object[size];
      }
      ~moechtegernvector() { delete data; }

      object* begin(void) { return data; }
      object* end(void) { return data + size; }
      int MachWasMitObject(object *t_object) { ... };
};

wenn ich da jetz ne iteratorklasse miteinbauen moechte, wie wuerde die dann ausssehen damit folgendes funktionieren wuerde:

moechtegernvector<int> test(20);
moechtegernvector<int>::iterator it = test.begin();
int erster_wert = test.MachWasMitObject(it);
...

Meep Meep

evilissimo

Meep Meep:
Falls es dich weiter bringt, deine klasse iterator sollte dann auch eine Template Klasse sein.

template < typename T >
  class Iterator
  {
     T * m_data;
   public:
    typedef T   value_type;
    typedef T*  pointer;
    typedef T&  reference;

    //...

    // evtl n voriger check 
    reference  operator*(){ return *m_data; }
    pointer    operator->(){ return m_data; }
  // usw
  };
template < typename T >
  class MeinContainer
  { 
   public:
     typedef Iterator<T> iterator; 
     iterator begin();
     iterator end();
  };

MfG

// Edit: Wer Fehler findet darf sie behalten. THERE'S NO WARRANTY

Meep Meep

reh

hoi eViLiSSiMo

das mein iterator auch ne template klasse sein sein soll, ist mir schon bewusst. mein ganzes problem bei der sache war, das ich nicht verstand, warum der vector-iterator nach aussenhin wie ein reiner pointer aussieht. die loesung: es ist auch nur ein normaler pointer. bei list is es dann ein iterator. mehr wolte ich eigendlich nicht wissen. naja vielleicht hab ich mich dann mal wieder bloed ausgedrueckt.

Meep Meep