Templateversion != C Version?

Hi,

ich bin am verzweifeln! Meine Templatefunktion unterscheidet sich total im ergebnis von der C version! Hier beide codes:

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); 
    }

    int memcmp2 ( const void *mem1, const void *mem2, unsigned int count) 
    {
        register const unsigned char *str1 = (unsigned char*)mem1;
        register const unsigned char *str2 = (unsigned char*)mem2;

        if (count > 0) 
        {
            for (count++; (count > 0) && (*str1++ == *str2++); --count);

            return !( *--str1 - *--str2 );
        }

        return -1;
    }

#include <iostream.h>
int main() 
{ 
    int x[4]= {0,1,2,3};
    int y[4]= {0,1,2,3};
    if (memcmp2(x,y,4))
        cout << "Gleich bei memcpy2!" << endl;

    if (compare(x,y,4))
        cout << "Gleich bei compare!" << endl;

    cin.get();
}

wo liegt der Fehöer?

k1ro

Ich weiss zwar nicht was zu deinem Fehler führt aber ein anderer ist mir gerade aufgefallen,
wenn bei deiner compare Funktion als count eine 0 übergeben wird und du --count machst, dann is das bei einem unsigned int nicht -1 sondern ...ähm... 2^32 -1 (???),
Also funktioniert die Überprüfung für den Fall nicht wirklich...
hoffe du verstehst was ich meine ^^

edit:
und wieso genau machst du das ?

(*mem1 && *mem2)

macht das das count nicht gleich ganz überflüssig ?

edit2:
Frage an alle (bin grad verwirrt)
wird *mem++ als *(mem++) oder als (*mem)++ ausgewertet?

edit3: (tag der edits -.-)
und mach doch bitte #include<iostream>

edit4:
arg, ich depp ^^

also, ich denk der fehler liegt hier:

(*mem1 && *mem2)

du schaust hier ob beide WERTE ungleich 0 sind, und was is der erste wert in dem Array? Richtig ! eine Null !

Ponto

Irgendwie ist hier vieles Murks:

1. #include <iostream.h>
2. In der C Version vergleichst du die ersten 4 Char des Arrays. Wenn ein Int 32 Bit hat, können dies 0,0,0,1 sein.
3. (*mem1 && *mem2) Wenn beide auf 0 zeigen, ist dies schon false.
4.
Die Template Version könnte sein:

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

         return count == 0;
     }

oder besser:

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

         return count == 0;
     }

Die C version würde ich entsprechend Implementieren.

Edit:
5. Das "register" in der C version ist überflüssig.
6. Warum hantiert man überhaupt so mit Speicher?

groovemaster

k1ro schrieb:

Frage an alle (bin grad verwirrt)
wird *mem++ als *(mem++) oder als (*mem)++ ausgewertet?

*(mem++)

Ponto schrieb:

Irgendwie ist hier vieles Murks

@---
Soll compare eigentlich C-Strings oder einfach nur Speicher vergleichen?