Come verificare se una stringa inizia con un'altra stringa in C?

Question

C'è qualcosa come startsWith(str_a, str_b) nella libreria C standard?

Dovrebbe portare i puntatori a due stringhe che terminano con nullbyte e dirmi se anche il primo appare completamente all'inizio del secondo.

Esempi:

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

Answer 1

Apparentemente non c'è alcuna funzione standard C per questo. Quindi:

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

---

Si noti che quanto sopra è bella e chiara, ma se si sta facendo in un loop stretto o di lavoro con molto stringhe di grandi dimensioni, non può offrire le migliori prestazioni, come esegue la scansione dell'intera lunghezza di entrambe le stringhe in avanti (strlen). Soluzioni come wj32's o Christoph's possono offrire prestazioni migliori (anche se this comment sulla vettorizzazione è al di là della mia conoscenza di C). Si noti anche Fred Foo's solution che evita strlen su str (ha ragione, non è necessario). Importa solo stringhe (molto) grandi o uso ripetuto in cicli stretti, ma quando è importante, conta.

Answer 2

Non c'è alcuna funzione standard per questo, ma è possibile definire

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

Non abbiamo preoccupare di str essere più breve di pre perché secondo lo standard C (7.21.4.4/2):

La funzione strncmp confronta non più di n caratteri (caratteri che seguono un carattere nullo non vengono confrontati) dalla matrice puntato dal s1 all'array puntato da s2."

Answer 3

Non sono un esperto in scrittura di codice elegante, ma ...

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

Answer 4

Usa strstr() funzione. Stra == strstr(stra, strb)

Answer 5

probabilmente sarei andare con strncmp(), ma solo per divertimento un'implementazione grezzo:

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

    return 1; 
} 

Answer 6

Perché ho eseguito la versione accettata e ha avuto un problema con una lunghissima str, ho dovuto aggiungere nel logica seguente:

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

Answer 7

ottimizzato (v.2 - corretta.):

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

Answer 8

Ottimizzato:

boolean StartsWith(char *s1, char *s2) 
{ 
    while (*s1++ == *s2++) 
    { 
    } 

    return *s2 == 0; 
}