Schleifenabbruch

Sunday

hi,

ich habe ne klasse Punkt und im program eine liste dieser punkte.

wenn ich durch die liste iteriere (vergleich von zwei punktlisten miteinander), reicht dann folgende abbruchbedingung oder ist es möglich das diese einmal nicht greift?

// Beispiel
Iterator it1 = Liste1.Begin();
Iterator it2 = Liste2.Begin();

while (*it1 == *it2)
{
  ++it1;
  ++it2;
}

ist es hier besser noch ein extra-abbruchkriterium einzuführen, ala

while (it1 != Liste1.End() && *it1 == *it2) { ... }

??

Hmm ich weiss wirklich nicht wie deine Begin() Funktion aussieht. Ich denke mal das so nicht viel passiert, da erst die Funktion Begin() aufgerufen wird DANN die Fkt Begin() vom 2ten.

Was mach die FKT? Das array "durchgehen", wenn ja bringt das nicht, da womöglich ( ka da ich die fkt begin() nicht kenne ) der iterator auf dem letzen Feld stehen wird.

normalerweise macht man eine schleife

von die ( wenn beide gleich lang sind ) von i = 0 bis zum ende der liste geht und dann in der schleife mit if vergleicht.

Oder du schreibst eine Funktion die als Parameter 2 Iterator hat z.b. vergleich( Iterator &eins, Iterator &zwei )

und beachtest in dieser fkt. die länge der jeweiligen Iterator ect pp ..

So kannst du leicht

it4 mit it6 vergleichen oder it8 mit it2.

Sunday

hm, okay vlei wars unglücklich beschrieben... hier mal bissel mehr code

Begin() liefert einen Zeiger auf das 0. Element der Liste
End() liefert einen Zeiger auf das n. Element der Liste
-> ausgehend davon, dass die liste von 0 - (n-1) geht

// Iterator
template <class T> class TRSIterator
{
  private:

    T *pItem;

  public:

    TRSIterator(T *rhs)
    { 
      pItem = rhs;       
    }

    int operator == (const TRSIterator<T> &rhs) const 
    {
      return (pItem == rhs.pItem);
    }

    const TRSIterator<T>& operator ++ ()
    {
      pItem++;
      return *this;
    }

    T& operator *  () const
    {
      return *pItem;
    } 

};

// Auszug aus der Listenklasse
template <class T> class TRSDynamicList : public TRSIterator<T>
{
  protected:

    T   *Items;        // Datenarray
    int  Count;        // Anzahl der Elemente im Array

  public:

    Iterator Begin() const { return Items;            }
    Iterator End()   const { return Items + Count;    }
};

template <class T>
int TRSDynamicList<T>::operator == (const TRSDynamicList<T> &rhs)
{
  // Listen müssen gleich lang sein
  if (rhs.Count != Count)
    return false;

  Iterator it1 = Begin();
  Iterator it2 = rhs.Begin();

  // Punktlisten vergleichen
  while (*it1 == *it2)
  {
    ++it1;
    ++it2;
  };

  return (it1 == End()) && (it2 == rhs.End());
}

achso jetzt check ich das mit dem operator == erst.

also ich denke du brauchst die extra abbruchbed. nicht. aber eine mehr reinmachen ist nie falsch