Hàm xử lý chuỗi trong C: strlen, strcpy, strcat, strcmp và các hàm khác

Mọi hàm trong <string.h> đều là một vòng lặp nhỏ chạy trên mảng char và dừng ở ký tự kết thúc null. Khi đã hiểu điều đó, thư viện này không còn là một danh sách tên khó hiểu mà trở thành vài vòng lặp bạn hoàn toàn có thể tự viết. Trang này trình bày những hàm gánh gần như toàn bộ công việc thực tế, cùng các quy tắc kích thước giúp chúng không ghi vượt quá cuối buffer.

Mọi thứ ở đây chỉ cần một dòng include:

#include <string.h>

strlen: có bao nhiêu ký tự

strlen đếm số byte cho đến ký tự kết thúc, không tính ký tự kết thúc. Hàm trả về size_t, nên hãy in bằng %zu.

#include <stdio.h>
#include <string.h>

int main(void) {
    char word[32] = "banana";

    printf("strlen = %zu\n", strlen(word));
    printf("sizeof = %zu\n", sizeof word);
    return 0;
}

strlen là 6; sizeof là 32. Giá trị thứ nhất là văn bản, giá trị thứ hai là vùng lưu trữ. Xem trang về chuỗi để hiểu vì sao sự phân biệt này quan trọng đến vậy.

strlen duyệt toàn bộ chuỗi mỗi lần gọi, nên đừng đặt nó trong điều kiện vòng lặp (loop) khi chuỗi không thay đổi:

/* re-counts the whole string on every iteration */
for (size_t i = 0; i < strlen(s); i++) { ... }

/* count once */
size_t n = strlen(s);
for (size_t i = 0; i < n; i++) { ... }

strcpy và strncpy: sao chép

strcpy(dst, src) sao chép các ký tự cùng ký tự kết thúc. Hàm không biết dst lớn bao nhiêu, nên nơi gọi phải đảm bảo dst chứa được ít nhất strlen(src) + 1 byte.

#include <stdio.h>
#include <string.h>

int main(void) {
    char src[] = "portable";
    char dst[16];

    strcpy(dst, src);
    printf("%s\n", dst);

    /* the sizing rule, checked explicitly */
    if (strlen(src) + 1 <= sizeof dst) {
        printf("fits with %zu bytes to spare\n", sizeof dst - strlen(src) - 1);
    }
    return 0;
}

strncpy nhận số lượng tối đa, nhưng có một cái bẫy nổi tiếng: khi chuỗi nguồn dài ít nhất n byte, nó sao chép đúng n ký tự và không có ký tự kết thúc. Luôn tự thêm ký tự kết thúc:

#include <stdio.h>
#include <string.h>

int main(void) {
    char src[] = "a very long project name";
    char dst[10];

    strncpy(dst, src, sizeof dst - 1);
    dst[sizeof dst - 1] = '\0';        /* required, not optional */

    printf("[%s]\n", dst);
    return 0;
}

sizeof dst - 1 cộng với ký tự kết thúc viết tường minh là mẫu cần ghi nhớ. (strncpy còn đệm số 0 vào các chuỗi nguồn ngắn cho đủ n byte, rất phí công với buffer lớn: hàm này được thiết kế cho bản ghi có độ rộng cố định, không phải để đảm bảo an toàn.)

strcat và strncat: nối chuỗi

strcat(dst, src) nối src vào cuối nội dung đang có trong dst. Đích phải chứa được cả hai chuỗi cộng một ký tự kết thúc, và phải đang chứa một chuỗi hợp lệ: nối vào vùng nhớ chưa khởi tạo là undefined behavior.

#include <stdio.h>
#include <string.h>

int main(void) {
    char path[64] = "/home/ada";

    strcat(path, "/");
    strcat(path, "notes.txt");

    printf("%s\n", path);
    printf("used %zu of %zu bytes\n", strlen(path) + 1, sizeof path);
    return 0;
}

Chú ý char path[64] = "/home/ada"; thay vì char path[64];: chính phần khởi tạo khiến nó là một chuỗi hợp lệ cho lần gọi strcat đầu tiên.

strncat(dst, src, n) nối tối đa n ký tự và luôn thêm ký tự kết thúc, nên n là chỗ trống còn lại chứ không phải tổng kích thước buffer:

strncat(dst, src, sizeof dst - strlen(dst) - 1);

Mỗi lần gọi strcat lại quét đích từ đầu để tìm điểm cuối. Ghép một chuỗi dài trong vòng lặp theo cách đó có độ phức tạp bậc hai; với dữ liệu lớn, hãy tự theo dõi vị trí ghi hoặc dùng snprintf, được trình bày trong trang chuyển đổi chuỗi.

strcmp: so sánh

== so sánh địa chỉ, nên cho ra false với hai mảng khác nhau dù chứa cùng nội dung. strcmp so sánh các ký tự và trả về dấu của độ chênh lệch.

#include <stdio.h>
#include <string.h>

int main(void) {
    char a[] = "apple";
    char b[] = "apple";
    char c[] = "banana";

    const char *pa = a;
    const char *pb = b;
    printf("pa == pb (addresses)? %s\n", pa == pb ? "yes" : "no");
    printf("strcmp(a, b) == 0?  %s\n", strcmp(a, b) == 0 ? "yes" : "no");

    printf("strcmp(a, c) sign: %s\n", strcmp(a, c) < 0 ? "a before c" : "a after c");
    return 0;
}

Ba quy tắc:

• Kiểm tra bằng nhau bằng strcmp(a, b) == 0. Viết if (strcmp(a, b)) nghĩa là "nếu chúng khác nhau", và gần như ai cũng đọc ngược.
• Chỉ dấu của kết quả là được định nghĩa. Đừng so sánh kết quả với 1 hay -1.
• Thứ tự dựa trên giá trị byte, nên "Zebra" đứng trước "apple" trong ASCII. Để so sánh không phân biệt hoa thường, hãy chuyển cả hai bản sao về chữ thường trước: strcasecmp hay gặp là phần mở rộng của POSIX, không thuộc chuẩn C.

strncmp(a, b, n) chỉ so sánh n ký tự đầu, đây là cách gọn gàng để kiểm tra tiền tố:

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *url = "https://coddy.tech";

    if (strncmp(url, "https://", 8) == 0) {
        printf("secure URL\n");
    }
    return 0;
}

strchr và strstr: tìm kiếm

strchr(s, ch) tìm lần xuất hiện đầu tiên của một ký tự; strrchr tìm lần cuối. strstr(haystack, needle) tìm một chuỗi con. Cả ba đều trả về con trỏ trỏ vào chuỗi gốc, hoặc NULL khi không tìm thấy.

#include <stdio.h>
#include <string.h>

int main(void) {
    char email[] = "ada@coddy.tech";

    char *at = strchr(email, '@');
    if (at != NULL) {
        printf("'@' at index %td\n", at - email);
        printf("domain: %s\n", at + 1);
    }

    char *dot = strrchr(email, '.');
    printf("extension: %s\n", dot != NULL ? dot + 1 : "(none)");

    if (strstr(email, "coddy") != NULL) {
        printf("contains \"coddy\"\n");
    }
    return 0;
}

Lấy con trỏ trả về trừ đi điểm đầu chuỗi sẽ được chỉ số; kiểu của nó là ptrdiff_t, in bằng %td. Vì kết quả trỏ vào bên trong mảng gốc, at + 1 chính là phần còn lại của chuỗi mà không cần sao chép gì: một thành ngữ rất phổ biến trong C.

Luôn kiểm tra NULL trước khi giải tham chiếu. strchr(email, '@') + 1 trên một chuỗi không có @ sẽ tính địa chỉ từ NULL, và chương trình không còn được định nghĩa nữa.

Tách chuỗi

C không có hàm split, nhưng strchr cộng một ký tự kết thúc là đủ để tách ngay tại chỗ. Ví dụ này cắt một địa chỉ email thành phần người dùng và tên miền:

#include <stdio.h>
#include <string.h>

int main(void) {
    char input[] = "ada@coddy.tech";
    char user[32];
    char domain[64];

    char *at = strchr(input, '@');
    if (at == NULL) {
        printf("not an email address\n");
        return 1;
    }

    size_t user_len = (size_t)(at - input);
    if (user_len >= sizeof user) {
        printf("user part too long\n");
        return 1;
    }

    memcpy(user, input, user_len);
    user[user_len] = '\0';

    strncpy(domain, at + 1, sizeof domain - 1);
    domain[sizeof domain - 1] = '\0';

    printf("user:   %s\n", user);
    printf("domain: %s\n", domain);
    return 0;
}

memcpy sao chép đúng số byte chỉ định mà không quan tâm đến ký tự kết thúc, đúng thứ bạn cần khi đã biết độ dài. Sau đó ký tự kết thúc được viết thủ công.

Ví dụ hoàn chỉnh: chuẩn hóa tên

Kết hợp mọi thứ ở trên: cắt khoảng trắng, so sánh, sao chép và nối chuỗi:

#include <stdio.h>
#include <string.h>
#include <ctype.h>

int main(void) {
    char first[32] = "  ada  ";
    char last[32]  = "lovelace";
    char full[80];

    /* skip leading spaces */
    char *start = first;
    while (*start == ' ') {
        start++;
    }

    /* cut trailing spaces */
    size_t len = strlen(start);
    while (len > 0 && start[len - 1] == ' ') {
        start[--len] = '\0';
    }

    /* capitalize the first letter of each part */
    start[0] = (char)toupper((unsigned char)start[0]);
    last[0]  = (char)toupper((unsigned char)last[0]);

    /* join with a bounded copy */
    strncpy(full, start, sizeof full - 1);
    full[sizeof full - 1] = '\0';
    strncat(full, " ", sizeof full - strlen(full) - 1);
    strncat(full, last, sizeof full - strlen(full) - 1);

    printf("[%s]\n", full);
    printf("is it Ada Lovelace? %s\n",
           strcmp(full, "Ada Lovelace") == 0 ? "yes" : "no");
    return 0;
}

Mọi lần ghi đều bị giới hạn bởi chính sizeof của đích, và mọi strncpy đều đi kèm một ký tự kết thúc viết tường minh. Áp dụng kỷ luật đó một cách nhất quán là điều làm cho code xử lý chuỗi trong C an toàn.

Các quy tắc kích thước cần nhớ

• strcpy cần strlen(src) + 1 byte trống ở đích.
• strcat cần strlen(dst) + strlen(src) + 1.
• Sau strncpy, tự viết dst[n - 1] = '\0'.
• Với strncat, số lượng là chỗ trống còn lại: sizeof dst - strlen(dst) - 1.
• Kiểm tra strchr và strstr có trả về NULL không trước khi dùng kết quả.
• Chỉ dùng sizeof dst khi dst là một mảng thật. Bên trong một hàm nhận char *dst, sizeof cho ra kích thước của con trỏ, nên hãy truyền độ dài buffer như một tham số riêng.