2 Array miteinander vergleichen (gleich lang)

7H3 N4C3R

Es funktioniert dann (oder kann nur dann funktionieren), wenn es gültiges C++ ist. As simple as that.
Außerdem funktioniert es nur dann, wenn es einen operator==( T, U) gibt.

Ich würde ersteres bevorzugen, allerdings fragst Du da die Size nicht ab. Und sobald die erste Gleicheit fehlschlägt, kannst Du abbrechen.

Sunday

naja die funktion habe ich aus ne klasse herausgenommen, bevor die aufgerufen wird, wird auf gleiche laenge geprueft. einen operator == (T, U) gibt es auch fuer die entsprechenden datentypen (solange keine build-in).

ich möchte halt gerne wissen, warum es denn funktioniert. kann es denn nicht passieren, das am array-ende, wenn ich dann quasi ausserhalb des array auf den speicher zugreife, dass dann diese elemente trotzdem gleich sind?

Ich würd es einfach und direkt schreiben:

template< T t, U t >
bool IsEqual( const T* rhs, const U* lhs, size_t size )
{
   for( size_t i = 0; i < size; ++i )
   {
      if( *rhs != *lhs )
          return false;
      ++rhs;
      ++lhs;
   }
   return true;
}

Wer will kann noch ++rhs und ++lhs in den for-kopf packen.

Seh gerade hab nen Tippfehler drin muss natürlich template< typename T, typename U > heißen.

Was ist wenn zufälligerweise lhsItem[size] == rhsItem[size] ist?

Uups, darauf ist ja schon jemand gekommen Habs vorhin nicht gsehen.

Werner Salomon

Hallo Sunday,

an dieser Stelle

Sunday schrieb:

while (*lhsItem == *rhsItem)
  {
    ++lhsItem;
    ++rhsItem;
  }

werden zwei Pointer inkrementiert und anschließend dereferenziert ohne abzuprüfen, ob das Ende des jeweiligen Bereichs erreicht ist. Das Verhalten ist nicht definiert. Stell Dir einfach mal vor, die Arrays wären gleich, dann würdest Du die nächsten beiden Objekte hinter (!) den Arrays miteinander vergleichen. Das geht bei nicht trivialen Typen (z.B. std::string) praktisch immer schief. Und auch bei trivialen Typen kann es in einer 'memory protection' enden.

Sunday schrieb:

// Erfolg, wenn am letzten Element angekommen
  return (lhsItem == (lhs + Size));

.. nicht ganz. Erfolg, wenn das Memory hinter den Arrays zufällig nicht identisch ist.

Sunday schrieb:

oder doch lieber alt-bewertes verwenden?

template <typename T, typename U>
bool DoCompare(const T *lhs, const U *rhs, const u_long Size)
{
  const T *lhsItem = lhs;
  const U *rhsItem = rhs;

  // Array-Elemente vergleichen
  for (u_long i = 0; i < Size; ++i)
    if (*lhsItem++ != *rhsItem++) return false;
 
  return true;
}

das sollte funktionieren. Wenn Du noch ein bißchen optimieren willst, kannst Du Dir ein inkrement sparen und eine lokale Variable - etwa so:

template <typename T, typename U>
bool DoCompare(const T *lhs, const U *rhs, unsigned Size)
{
    const T* ende = lhs + Size;
    // Array-Elemente vergleichen
    for( ; lhs != ende; ++lhs, ++rhs )
        if( *lhs != *rhs ) 
            return false;
    return true;
}

Gruß
Werner

Sunday

ich haette, schwören können, dass ich das irgendwo einmal gelesen habe, dass das so funktioniert. naja. danke euch.

anonymus

Sunday schrieb:

ich haette, schwören können, dass ich das irgendwo einmal gelesen habe, dass das so funktioniert. naja. danke euch.

Das funktioniert auch.
Die aufrufende Funktion muss aber sicherstellen, dass sich auf den letzten
Plätzen jeweils ein Stopper-Element befindet, die nicht gleich sind.

Somit bricht die Schleife in jedem Fall beim letzten Element ab.

Dann funktioniert auch der Vergleich unter der Schleife,
ob man beim letzten Element angekommen ist.

Vorteil der while-Schleife gegenüber der for-Schleife ist,
dass man nur die Hälfte der Vergleiche braucht:

while:
~ N Vergleiche (nur die Inhalte an jeder Zeigerposition)

for:
~ 2N Vergleiche (N mal die Inhalte, N mal die Zählvariable)

otze

aber nur, wenn dir der compiler nicht mit drin rumpfuscht

anonymus

otze schrieb:

aber nur, wenn dir der compiler nicht mit drin rumpfuscht

der hat sich da gefälligst rauszuhalten.
Basta