memcmp funktion bringt PC zum absturz?

Hi,

ich habe mal versucht eine Art memcmp funktion zu coden, doch naja... mit geringen erfolg!

Hier der code:

template <class T> inline bool memcpy (T const* l1, T const* l2, unsigned int count) 
{ 
    while((*l1 && *l2) && (*l1++ == *l2++)); 

    return (*l1-*l2); 
}

des weiteren weis ich nicht wie ich die variable count einsetzen kann, z.B. zum begrenzen des vergleichs wie bei der echten memcmp funktion.

Kann mir jemand helfen?

interpreter

Deine Funktion würde nur für Nullterminierte Arrays funktionieren
Beide Parameter sind const -> Du kannst nicht in das Zielarray kopieren
Du kopierst nirgends ( == ist zum Vergleichen da)
Dein Rückgabewert ist Schwachsinn

Gerard

ist dir nicht aufgefallen das klein L hier verwirung stiftet?

Shlo

memcmy kopiert Daten Byteweise, bei dir ist es eine einfache Zuweisung. Außerdem, was gefällt dir nicht an std::memcpy? Oder ist es wieder so eine Art Übung?

ich rede von einer memcmp funktion und nicht von einer memcpy funktion!

sorry hatte ich versehentlich falsch abgetippt es geht um eine compare funktion und keine copy funktion!

Shlo

zeta3 schrieb:

ich rede von einer memcmp funktion und nicht von einer memcpy funktion!

sorry hatte ich versehentlich falsch abgetippt es geht um eine compare funktion und keine copy funktion!

Gilt das gleiche, deine Funktion ähnelt eher std::equal - mit memcmp hat es wenig zu tun. Zudem führt memcmp einen lexikographischen Vergleich durch, deshalb ist das Ergebnis ein integer und kein bool.

habs hin bekommen!

irgendwelche optimierungstipps?

template <class T> inline bool memcmp(const T *s1, const T *s2, unsigned int count)
{
    for (const T *sp1 = s1, const T *sp2 = s2; count > 0; ++sp1, ++sp2, --count)
    {
        if (*sp1 != *sp2)
        {
            return (*sp1 < *sp2) ? false : true;
        }
    }

    return false;
}

Shlo

zeta3 schrieb:

habs hin bekommen!

irgendwelche optimierungstipps?
(*sp1 < *sp2) ? false : true;

Wie ein bool funktioniert, weißt du anscheinend nicht, oder?

du kennst anscheinend nicht das böse warning wenn man einen bool als rückgabewert erwartet jedoch man ein unsigned T zurück gibt? oder?

Shlo

zeta3 schrieb:

du kennst anscheinend nicht das böse warning wenn man einen bool als rückgabewert erwartet jedoch man ein unsigned T zurück gibt? oder?

Sicher doch, aber was hat es mit deiner Funktion oder mit dem von mir kommentierten Code zu tun?

lass das ? false:true; mal weg und viel spass mit der warning, find ich fein das du warnings ignorierst

Shlo

Ein Vergleichsoperator liefert einen bool, deshalb kann es keine Warnungen geben. Ansonsten würde ich den Compiler ganz schnell wechseln...

HumeSikkins

lass das ? false:true; mal weg und viel spass mit der warning, find ich fein das du warnings ignorierst

Wenn du das ? false : true einfach weglässt, bekommst du nicht nur eine Warnung sondern auch noch ein anderes Verhalten.
Ersetzt du aber einfach dein hässliches
return (*sp1 < *sp2) ? false : true;
durch ein
return !(*sp1 < *sp2);
dann ist alles fein.

Shlo

HumeSikkins schrieb:

return !(*sp1 < *sp2);
dann ist alles fein.

oder return *sp1 >= *sp2, je nachdem ob der verwendete Typ diesen Operator implementiert

HumeSikkins

Desweiteren verstehe ich den Zusammenhang zwischen dem Namen memcmp und der Implementation nicht. Wieso liefert die Funktion true, wenn s2 lexikographisch größer als s1 ist?

Imo sollte dein Memcmp entweder ein int liefern (0 -> gleich, -1 -> s1 kleiner, 1 -> s2 kleiner) oder aber nur true, wenn s1 == s2.

// Ist das richtig?
template <class T> inline bool memcmp(const T *s1, const T *s2, unsigned int count)
{
     while (count && *s1++ == *s2++)
          --count;
     return count == 0;
}

Und btw. warum verwendest du nicht std::equal oder std::lexicographical_compare?

@Humme:
lernen

@Humme
hab noch weiter optimiert

template <class T> inline bool compare (const T * mem1, const T * mem2, unsigned int count) 
{ 
    while((*mem1 && *mem2) && (*mem1++ == *mem2++) && (--count>0));

    return !(*mem1 - *mem2); 
}

groovemaster

Shlo schrieb:

memcmy [...]

Hätte nicht gedacht, dass jemand der Verwirrung noch eins draufsetzen kann.

zeta3 schrieb:

return !(*mem1 - *mem2);

Magst du den Gleichheits-Operator (==) grundsätzlich nicht oder nur hier? Sollte ein Compiler nicht mitbekommen was du hier willst, brummt er dir dafür gerechterweise 'ne Strafrunde auf.

interpreter

Ist das nicht Schwachsinn?

((*mem1 && *mem2)

Warum sollte compare bei einer 0 in einem int-array aufhören zu vergleichen?

randa

@zeta: Teste deine optimierungen lieber vorher, denn diese Funktion wird nicht funktionieren. Und vermeide die Zeigerarithmetik.

template <class T>
bool cmp (const T *Left, const T *Right, size_t Size)
{
	for (size_t i=0; i<Size; i++) if (*Left++!=*Right++) return false;
	return true;
}

würde zum Beispiel checken, ob alle Elemente gleich sind und liefert entsprechendes zurück. Das != kannst du durch irgendeinen anderen Vergleichsoperator erstetzen.

Shlo

groovemaster2002 schrieb:

Shlo schrieb:

memcmy [...]

Hätte nicht gedacht, dass jemand der Verwirrung noch eins draufsetzen kann.

Um halb zwölf in der Nacht kann leicht passieren, dass einem die Kraft nicht mehr reicht, Beiträge ohne Fehler zu verfassen und vorallem diese später zu erkennen und zu korrigieren. Deshalb sollte man sich eigentlich nicht wundern...

Whoops, schon wieder ein Fehler