strstr() - string.h

czy ktoś mógłby przetłumaczyć na C++ lub chociaz opisać jak działa (w miarę dokładnie) algorytm fukncji strstr która jest w standardowych bibliotekach kompilatora w asemblerze:

char * _FARFUNC strstr(const char *str1, const char *str2) 
{ 
        if (!*str2) 
                return((char *)str1);           /* return str1 if str2 empty */ 

        pushDS_ 
#if !(LDATA) 
    _ES = _DS; 
#endif 
asm     cld 

asm     LES_    di, str1 
        pushES_ 
asm     mov     bx, di 
asm     xor     ax, ax 
asm     mov     cx, -1 
asm     repnz   scasb 
asm     not     cx 
asm     xchg    cx, dx 

asm     LES_    di, str2 
        pushES_ 
asm     mov     bp, di 
asm     xor     ax, ax 
asm     mov     cx, -1 
asm     repnz   scasb 
asm     inc     cx 
asm     not     cx 
        popDS_ 
        popES_ 

strLoop: 
asm     mov     si, bp 
asm     lodsb 
asm     xchg    di, bx 
asm     xchg    cx, dx 
asm     repnz   scasb 
asm     mov     bx, di 
asm     jnz     NotFound 
asm     cmp     cx, dx 
asm     jnb     FirstMatch 

NotFound: 
#if (LDATA) 
asm     xor     bx, bx 
asm     mov     es, bx 
#endif 
asm     mov     bx, 1 
asm     jmp     short End 

FirstMatch: 
asm     xchg    cx, dx 
asm     jcxz    End 
asm     mov     ax, cx 
asm     dec     cx 
asm     repz    cmpsb 
asm     mov     cx, ax 
asm     jnz     strLoop 

End: 
        popDS_ 
#if (LDATA) 
    return (char _es *)(_BX - 1); 
#else 
    return (char *)(_BX - 1); 
#endif 
}

tlumaczenie sobie odpuszcze
co do "jak to dziala":

najprostszy algorytm wyglada tak:

1. wyszukaj pierwszej litery
2. sprawdz czy reszta wyrazu sie zgadza

implementacja w c wyglada nastepujaco

char *my_strstr( const char *siano, const char *igla )
{
  const char *ps = siano, *pi;

  while( *siano )
  {
    /* jezeli znaleziono pierwsza liter */
    if( *siano == *igla )
    {
       /* to idz dopoki litery sie zgadzaja */
       for( pi = igla, ps = siano; *pi && *ps && *pi == *ps; pi++, ps++ );
       
       /* cala igle przeszlismy ? to znalezlismy */
       if( *pi == '\0' )
         return (char*) siano;
    }
    
    /* idziemy dalej */
    siano++;
  }
  
  return NULL;
}

ofc nie jest to najszybsza metoda, ale zazwyczaj wystarcza
jezeli interesuje cie implementacja szybkich metod to polecam zapoznanie sie z algorytmami:
KMP (Knutha-Morrisa-Pratta) (polegajacy na stworzeniu tabeli przesunienc)
KR (Karpa-Tabina) (polegajacy na wyliczeniu hasha szukanego ciagu)
ew rozne inne wariacje typu BM (Boyera-Moore) or sth

no właśnie chodziło mi o to jakiej złożoności jest algorytm tej fukncji i widze ze to najprostsza wersja bez przesunięć, dzięki za pomoc