Напишите свои аналоги функций strlen(), strcpy(), strcmp() и сравните с библиотечными.

int strlen(char* c_str)
{
    int count=0;
    while(*c_str++) ++count;
    return count;
}
 
/************************************************/
 
void strcpy(char* c_str1,char* c_str2)
{
    while(*c_str2++=*c_str1++);
}
 
/************************************************/
 
int strcmp(char* c_str1,char* c_str2)
{
    if (strlen(c_str1)!=strlen(c_str2)) return 0;
    int count=strlen(c_str1)+1;
    while(*c_str1++==*c_str2++) --count;
    if (count) return 0;
    return 1;
}

/* Copy SRC to DEST.  */
extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     __THROW __nonnull ((1, 2));
 
/************************************************/
 
extern int strcmp (__const char *__s1, __const char *__s2)
     __THROW __attribute_pure__ __nonnull ((1, 2));
 
/************************************************/
 
extern size_t strlen (__const char *__s)
     __THROW __attribute_pure__ __nonnull ((1));

//header
UINTPTR _fastcall   slen_b(const UINT8* pstr);
UINTPTR _fastcall   slen_w(const UINT16* pstr);
UINTPTR _fastcall   slen_d(const UINT32* pstr);
inline  UINTPTR slen_tselect(const void* pstr,tselect<1>)   {return slen_b((const UINT8*)pstr);}
inline  UINTPTR slen_tselect(const void* pstr,tselect<2>)   {return slen_w((const UINT16*)pstr);}
inline  UINTPTR slen_tselect(const void* pstr,tselect<4>)   {return slen_d((const UINT32*)pstr);}
template<class T> inline UINTPTR slen(const T* pstr)    {return slen_tselect(pstr,tselect<sizeof T>());};
 
//cpp
template<class T> __forceinline UINTPTR slen_sse2(const T* pstr){
    const T* ptr = pstr;
    if (ptr){
        if (!((UINTPTR)ptr & (sizeof T - 1))){
            vec_sse_proto<T>    a,b;
            a.setz();       //xorps xmm0,xmm0
            UINT32  result = (UINTPTR)ptr & 15;
            ptr = (T*)((UINT8*)ptr - result);
            result = 0xffffffff << result;
            b.load(ptr);    //movaps    xmm1,[ptr]
            b.pcmpeq(a);    //pcmpeq[b/w/d] xmm1,xmm0
            ptr += 16/sizeof T;
            result &= b.movemaskb();    //movemaskb r32,xmm1
            while(!result){
                b.load(ptr);
                b.pcmpeq(a);
                ptr += 16/sizeof T;
                result = b.movemaskb();     
            }
            result = bit_sf(result);
            ptr = (T*)((UINT8*)ptr + result - 16);
        }else{
            //если данные не выровнены по размеру типа
            while(*ptr++);
        }
    }
    return ptr - pstr;
}
 
UINTPTR  _fastcall  slen_b(const UINT8* pstr)   {return slen_sse2(pstr);}
UINTPTR  _fastcall  slen_w(const UINT16* pstr)  {return slen_sse2(pstr);}
UINTPTR  _fastcall  slen_d(const UINT32* pstr)  {return slen_sse2(pstr);}

//header
UINTPTR _fastcall scopy_b(UINT8* pdest,const UINT8* psrc);
UINTPTR _fastcall scopy_w(UINT16* pdest,const UINT16* psrc);
UINTPTR _fastcall scopy_d(UINT32* pdest,const UINT32* psrc);
дописать
inline  UINTPTR scopy_tselect(void* pdest,const void* psrc,tselect<1>){
   return scopy_b((UINT8*)pdest,(const UINT8*)psrc);
}
inline  UINTPTR scopy_tselect(void* pdest,const void* psrc,tselect<2>){
   return scopy_w((UINT16*)pdest,(const UINT16*)psrc);
}
inline  UINTPTR scopy_tselect(void* pdest,const void* psrc,tselect<4>){
   return scopy_d((UINT32*)pdest,(const UINT32*)psrc);
}
template<class TYPE> inline UINTPTR scopy(TYPE* pdest,const TYPE* psrc) {
   return scopy_tselect(pdest,psrc,tselect<sizeof TYPE>());
}
//cpp
 template<class T> __forceinline UINTPTR scopy_sse2(T* pdest,const T* psrc){
    const T* ps = psrc;
    if (pdest && psrc){
        if (!((UINTPTR)ps & (sizeof T -1))){
            while((UINTPTR)ps & 15){
                if (!(*pdest++ = *ps++))
                    return ps-psrc;
            }
            while(1){
                vec_sse_proto<T> v,z;
                v.load(ps);     //movaps  xmm0,[src]
                z.setz();       //pxorps      xmm1,xmm1
                z.pcmpeq(v);        //pcmpeq[b/w/d]  xmm1,xmm0
                if (z.movemaskb())  //movemaskb  r32,xmm1
                    break;
                v.storeu_fast(pdest);   //movlps [dest],xmm0
                            //movhps [dest+8],xmm0
                ps += 16/sizeof T;
                pdest += 16/sizeof T;
            }
        }
        while(*pdest++ = *ps++);
    }
    return ps-psrc;
}
 
UINTPTR _fastcall   scopy_b(UINT8* pdest,const UINT8* psrc){
    return scopy_sse2(pdest,psrc);
}
UINTPTR _fastcall   scopy_w(UINT16* pdest,const UINT16* psrc){
    return scopy_sse2(pdest,psrc);
}
UINTPTR _fastcall   scopy_d(UINT32* pdest,const UINT32* psrc){
    return scopy_sse2(pdest,psrc);
}

unsigned str_len(const char * str){
    int i=-1;
    while (str[++i]);
    return i; 
}
char * str_cpy(const char * from, char * to){
    char * x=to;
    while(*to++=*from++);  //скреативил из книги
    return x;  //насчет этого не уверен
}
char * str_chr(char * str, char chr){ //лишняя, но пусть будет
    while(*str)
        if (*str++==chr) return --str;
    return 0;
}
short str_cmp(const char * a, const char * b){
    if (str_len(a)>str_len(b)) return -1;
    if (str_len(a)<str_len(b)) return 1;
    for (int i=0; a[i]; i++){
        if (a[i]>b[i]) return -1;
        if (a[i]<b[i]) return 1;
    }
    return 0;
}