Jak sprawdzić, czy ciąg znaków zaczyna się od innego ciągu w C?

Czy jest coś takiego startsWith(str_a, str_b)w standardowej bibliotece C?

Powinien wziąć wskaźniki do dwóch ciągów kończących się na nullbajtach i powiedzieć mi, czy pierwszy z nich pojawia się również w całości na początku drugiego.

Przykłady:

"abc", "abcdef" -> true
"abcdef", "abc" -> false
"abd", "abdcef" -> true
"abc", "abc"    -> true

Najwyraźniej nie ma do tego standardowej funkcji C. Więc:

bool startsWith(const char *pre, const char *str)
{
    size_t lenpre = strlen(pre),
           lenstr = strlen(str);
    return lenstr < lenpre ? false : memcmp(pre, str, lenpre) == 0;
}

Zauważ, że powyższe jest ładne i wyraźne, ale jeśli robisz to w ciasnej pętli lub pracujesz z bardzo dużymi strunami, nie oferuje najlepszej wydajności, ponieważ skanuje całą długość obu strun z przodu ( strlen). Rozwiązania takie jak wj32 lub Christoph's mogą oferować lepsze wyniki (chociaż ten komentarz o wektoryzacji jest poza moim zasięgiem C). Należy również pamiętać, rozwiązanie Fred Foo który unika strlenon str(on ma rację, że to niepotrzebne, jeśli używasz strncmpzamiast memcmp). Ma znaczenie tylko w przypadku (bardzo) dużych strun lub wielokrotnego użycia w ciasnych pętlach, ale kiedy ma to znaczenie, ma znaczenie.

Nie ma do tego standardowej funkcji, ale możesz ją zdefiniować

bool prefix(const char *pre, const char *str)
{
    return strncmp(pre, str, strlen(pre)) == 0;
}

Nie musimy się martwić, strże prebędziemy krótsi niż dlatego, że według standardu C (7.21.4.4/2):

strncmpFunkcja porównuje nie więcej niż nznaków (znaki, które następują znak NULL nie są porównywane) z tablicy wskazywanej przez s1do tablicy wskazywanej przez s2„.

Prawdopodobnie wybrałbym strncmp(), ale dla zabawy surowa implementacja:

_Bool starts_with(const char *restrict string, const char *restrict prefix)
{
    while(*prefix)
    {
        if(*prefix++ != *string++)
            return 0;
    }

    return 1;
}

Nie jestem ekspertem w pisaniu eleganckiego kodu, ale ...

int prefix(const char *pre, const char *str)
{
    char cp;
    char cs;

    if (!*pre)
        return 1;

    while ((cp = *pre++) && (cs = *str++))
    {
        if (cp != cs)
            return 0;
    }

    if (!cs)
        return 0;

    return 1;
}

Użyj strstr()funkcji. Stra == strstr(stra, strb)

Zoptymalizowany (v.2. - poprawiony):

uint32 startsWith( const void* prefix_, const void* str_ ) {
    uint8 _cp, _cs;
    const uint8* _pr = (uint8*) prefix_;
    const uint8* _str = (uint8*) str_;
    while ( ( _cs = *_str++ ) & ( _cp = *_pr++ ) ) {
        if ( _cp != _cs ) return 0;
    }
    return !_cp;
}

Ponieważ uruchomiłem zaakceptowaną wersję i miałem problem z bardzo długim str, musiałem dodać następującą logikę:

bool longEnough(const char *str, int min_length) {
    int length = 0;
    while (str[length] && length < min_length)
        length++;
    if (length == min_length)
        return true;
    return false;
}

bool startsWith(const char *pre, const char *str) {
    size_t lenpre = strlen(pre);
    return longEnough(str, lenpre) ? strncmp(str, pre, lenpre) == 0 : false;
}

Lub połączenie tych dwóch podejść:

_Bool starts_with(const char *restrict string, const char *restrict prefix)
{
    char * const restrict prefix_end = prefix + 13;
    while (1)
    {
        if ( 0 == *prefix  )
            return 1;   
        if ( *prefix++ != *string++)
            return 0;
        if ( prefix_end <= prefix  )
            return 0 == strncmp(prefix, string, strlen(prefix));
    }  
}

EDYCJA: Poniższy kod NIE działa, ponieważ jeśli strncmp zwraca 0, nie wiadomo, czy zostało osiągnięte kończące 0 lub długość (rozmiar_bloku).

Dodatkowym pomysłem jest porównanie blokowe. Jeśli blok nie jest równy, porównaj ten blok z oryginalną funkcją:

_Bool starts_with_big(const char *restrict string, const char *restrict prefix)
{
    size_t block_size = 64;
    while (1)
    {
        if ( 0 != strncmp( string, prefix, block_size ) )
          return starts_with( string, prefix);
        string += block_size;
        prefix += block_size;
        if ( block_size < 4096 )
          block_size *= 2;
    }
}

Stałe 13, 64, 4096, a także potęgowanie z block_sizeto tylko domysły. Musiałby zostać wybrany dla użytych danych wejściowych i sprzętu.