Làm thế nào để kiểm tra xem một chuỗi có bắt đầu bằng một chuỗi khác trong C hay không?

Có một cái gì đó giống như startsWith(str_a, str_b)trong thư viện C tiêu chuẩn?

Nó sẽ đưa con trỏ đến hai chuỗi kết thúc bằng nullbyte và cho tôi biết liệu chuỗi đầu tiên có xuất hiện hoàn toàn ở đầu chuỗi thứ hai hay không.

Ví dụ:

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

Rõ ràng là không có chức năng C tiêu chuẩn cho việc này. Vì thế:

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

Lưu ý rằng phần trên rất hay và rõ ràng, nhưng nếu bạn đang thực hiện nó trong một vòng lặp chặt chẽ hoặc làm việc với các chuỗi rất lớn, nó không mang lại hiệu suất tốt nhất vì nó quét toàn bộ chiều dài của cả hai chuỗi phía trước ( strlen). Các giải pháp như wj32's hoặc Christoph's có thể mang lại hiệu suất tốt hơn (mặc dù nhận xét về vectơ hóa này nằm ngoài tầm ken của tôi về C). Cũng lưu ý giải pháp của Fred Foo tránh strlenbật str(anh ấy nói đúng, nó không cần thiết nếu bạn sử dụng strncmpthay thế memcmp). Chỉ quan trọng đối với các chuỗi (rất) lớn hoặc sử dụng lặp đi lặp lại trong các vòng lặp chặt chẽ, nhưng khi nó quan trọng, điều đó quan trọng.

Không có chức năng tiêu chuẩn cho việc này, nhưng bạn có thể xác định

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

Chúng tôi không phải lo lắng về str việc ngắn hơn prevì theo tiêu chuẩn C (7.21.4.4/2):

Các strncmpchức năng so sánh không hơn nký tự (nhân vật mà theo một ký tự null không so) từ mảng trỏ đến bởi s1để mảng trỏ đến bởi s2".

Tôi có thể sẽ đi với strncmp(), nhưng chỉ cho vui là một triển khai thô:

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

    return 1;
}

Tôi không phải là chuyên gia viết mã thanh lịch, nhưng ...

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

Sử dụng strstr()chức năng. Stra == strstr(stra, strb)

Tối ưu hóa (v.2. - đã sửa):

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

Vì tôi đã chạy phiên bản được chấp nhận và gặp sự cố với một chuỗi rất dài, tôi phải thêm vào logic sau:

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

Hoặc sự kết hợp của hai cách tiếp cận:

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

CHỈNH SỬA: Đoạn mã dưới đây KHÔNG hoạt động bởi vì nếu strncmp trả về 0, nó sẽ không biết liệu đã đạt đến kết thúc 0 hay độ dài (block_size) hay không.

Một ý tưởng bổ sung là so sánh khối khôn ngoan. Nếu khối không bằng nhau, hãy so sánh khối đó với hàm ban đầu:

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

Các hằng số 13, 64, 4096, cũng như các lũy thừa của block_sizechỉ là phỏng đoán. Nó sẽ phải được chọn cho dữ liệu đầu vào và phần cứng đã sử dụng.