Bài 11.815 phút đọc

strchr

Sau bài này bạn sẽ làm được

Dùng strchr và strrchr đúng cách
Xử lý trường hợp tìm ký tự null
Tách phần mở rộng của tên file bằng strrchr
Đếm số lần xuất hiện của một ký tự

Nhóm hàm tìm kiếm trong string.h đều trả về con trỏ chứ không phải chỉ số. Cách thiết kế đó ban đầu gây khó chịu, nhưng nó khiến việc tách chuỗi trở nên rất gọn, và nó là chìa khóa để đọc mã C của người khác.

#strchr và strrchr

#include <string.h>

char *strchr(const char *s, int c);    /* tìm từ đầu */
char *strrchr(const char *s, int c);   /* tìm từ cuối, chữ r là reverse */

Trả về con trỏ tới lần xuất hiện đầu tiên hoặc cuối cùng của ký tự c trong chuỗi, hoặc NULL nếu không có.

strchr.c

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

int main(void)
{
    const char *s = "a/b/c.txt";

    char *dau  = strchr(s, '/');
    char *cuoi = strrchr(s, '/');

    if (dau != NULL)
        printf("dau  tai chi so %td: [%s]\n", dau - s, dau);

    if (cuoi != NULL)
        printf("cuoi tai chi so %td: [%s]\n", cuoi - s, cuoi);

    if (strchr(s, 'z') == NULL)
        printf("khong co ky tu z\n");

    return 0;
}

terminal

./strchr

dau  tai chi so 1: [/b/c.txt]
cuoi tai chi so 3: [/c.txt]
khong co ky tu z

Đổi con trỏ thành chỉ số bằng phép trừ

char *p = strchr(s, '/');

if (p != NULL) {
    ptrdiff_t i = p - s;      /* hiệu hai con trỏ cho ra số phần tử giữa chúng */

    printf("%td\n", i);       /* %td là định dạng cho ptrdiff_t */
}

Kiểu ptrdiff_t khai báo trong stddef.h và là kiểu có dấu, đủ rộng để chứa hiệu của hai con trỏ bất kỳ trong cùng một mảng.

Tham số thứ hai có kiểu int, không phải char

char *strchr(const char *s, int c);

Hàm chuyển c về char trước khi so sánh. Kiểu int ở đây là di sản từ thời C chưa có nguyên mẫu, khi mọi tham số nhỏ hơn int đều tự động được mở rộng. Bạn cứ truyền ký tự bình thường, nhưng đừng ngạc nhiên khi thấy int trong tài liệu.

#Tìm chính byte kết thúc

const char *s = "hello";

char *p = strchr(s, '\0');    /* trả về địa chỉ byte kết thúc, KHÔNG phải NULL */

printf("%td\n", p - s);       /* 5, đúng bằng strlen(s) */

Hệ quả: kiểm tra NULL không đủ khi c có thể bằng 0

/* Hàm đếm số lần xuất hiện của ký tự c */
size_t dem(const char *s, char c)
{
    size_t n = 0;
    const char *p = s;

    while ((p = strchr(p, c)) != NULL) {
        ++n;
        ++p;                  /* nếu c là '\0', vòng lặp chạy ra ngoài chuỗi */
    }

    return n;
}

dem("hello", 'l');     /* 2, đúng */
dem("hello", '\0');    /* đọc ra ngoài mảng, hành vi không xác định */

Cách chữa là kiểm tra c ngay đầu hàm, hoặc dùng vòng lặp duyệt thường thay vì strchr.

size_t dem(const char *s, char c)
{
    if (c == '\0') return 0;      /* hoặc 1, tùy bạn định nghĩa */

    size_t n = 0;

    for (const char *p = s; *p != '\0'; ++p)
        if (*p == c) ++n;

    return n;
}

#Tách chuỗi bằng con trỏ

Tách phần mở rộng của tên file

phan-mo-rong.c

/* Trả về con trỏ tới phần mở rộng, không kể dấu chấm.
   Trả về NULL nếu không có phần mở rộng. */
const char *phan_mo_rong(const char *ten_file)
{
    const char *cham = strrchr(ten_file, '.');

    if (cham == NULL) return NULL;       /* không có dấu chấm nào */
    if (cham == ten_file) return NULL;   /* tên bắt đầu bằng dấu chấm, file ẩn */
    if (cham[1] == '\0') return NULL;    /* dấu chấm ở cuối, không có đuôi */

    return cham + 1;
}

terminal

./phan-mo-rong

a/b/c.txt      -> txt
anh.tar.gz     -> gz
khong_co_duoi  -> (khong co)
.gitignore     -> (khong co)
cuoi.          -> (khong co)

Ba dòng kiểm tra ở đầu hàm chính là phần khó của bài toán. Ai cũng viết được dòng strrchr, nhưng chỉ khi liệt kê đủ trường hợp biên thì hàm mới dùng được trong thực tế.

Tách tên file khỏi đường dẫn

const char *ten_file(const char *duong_dan)
{
    const char *xien = strrchr(duong_dan, '/');

    return xien != NULL ? xien + 1 : duong_dan;
}

ten_file("/home/an/bai.c");    /* "bai.c" */
ten_file("bai.c");             /* "bai.c" */
ten_file("/home/an/");         /* "" */

Trên Windows có hai loại dấu phân cách

const char *ten_file(const char *duong_dan)
{
    const char *a = strrchr(duong_dan, '/');
    const char *b = strrchr(duong_dan, '\\');
    const char *cuoi = a > b ? a : b;      /* NULL nhỏ hơn mọi địa chỉ hợp lệ */

    return cuoi != NULL ? cuoi + 1 : duong_dan;
}

So sánh hai con trỏ khác mảng về mặt chuẩn là không xác định, nhưng cách viết này phổ biến và hoạt động trên mọi nền tảng thực tế. Bản hoàn toàn đúng chuẩn cần kiểm tra NULL riêng cho từng cái.

Tách cặp khóa và giá trị

tach-cap.c

/* Tách dòng "khoa=gia_tri" thành hai phần.
   Sửa ngay trên chuỗi gốc nên chuỗi phải ghi được. */
int tach_cap(char *dong, char **khoa, char **gia_tri)
{
    char *bang = strchr(dong, '=');

    if (bang == NULL) return -1;

    *bang    = '\0';        /* cắt chuỗi làm đôi ngay tại dấu bằng */
    *khoa    = dong;
    *gia_tri = bang + 1;

    return 0;
}

char  dong[] = "ten=Nguyen Van A";
char *k, *v;

if (tach_cap(dong, &k, &v) == 0)
    printf("[%s] = [%s]\n", k, v);   /* [ten] = [Nguyen Van A] */

Kỹ thuật này sửa chuỗi gốc

Việc ghi byte 0 đè lên dấu bằng biến một chuỗi thành hai chuỗi mà không cần cấp phát gì. Rất hiệu quả, nhưng nó phá chuỗi ban đầu, và nó không dùng được với hằng chuỗi.

tach_cap("ten=An", &k, &v);       /* chương trình sập: ghi vào .rodata */

char dong[] = "ten=An";
tach_cap(dong, &k, &v);           /* đúng: mảng ghi được */

#Ba hàm họ hàng

Hàm	Tìm gì	Trả về
strchr(s, c)	Ký tự c, lần đầu tiên	Con trỏ tới nó, hoặc NULL
strrchr(s, c)	Ký tự c, lần cuối cùng	Con trỏ tới nó, hoặc NULL
strpbrk(s, tap)	Ký tự đầu tiên thuộc tập cho trước	Con trỏ tới nó, hoặc NULL
strspn(s, tap)	Độ dài đoạn đầu chỉ gồm ký tự trong tập	Số ký tự
strcspn(s, tap)	Độ dài đoạn đầu KHÔNG có ký tự nào trong tập	Số ký tự

ho-hang.c

const char *s = "  \t42abc";

/* Bỏ qua khoảng trắng đầu chuỗi */
size_t bo_qua = strspn(s, " \t\n");
printf("[%s]\n", s + bo_qua);          /* [42abc] */

/* Tìm ký tự đầu tiên không phải chữ số */
size_t so_chu_so = strspn(s + bo_qua, "0123456789");
printf("%zu chu so\n", so_chu_so);     /* 2 */

/* Tìm dấu toán tử đầu tiên */
char *toan_tu = strpbrk("a + b * c", "+-*/");
printf("[%s]\n", toan_tu);             /* [+ b * c] */

/* strcspn dùng để xóa ký tự xuống dòng, như Bài 11.3 */
char dong[] = "xin chao\n";
dong[strcspn(dong, "\n")] = '\0';

strspn và strcspn là cặp đối nhau

Hàm strspn đếm ký tự thuộc tập, còn strcspn đếm ký tự không thuộc tập. Chữ c trong tên là complement, tức phần bù. Ghép hai hàm này lại là bạn có một trình phân tích chuỗi đơn giản mà không cần thư viện gì thêm.

/* Tách chuỗi thành các từ, phân cách bằng khoảng trắng */
const char *p = s;

while (*p != '\0') {
    p += strspn(p, " \t\n");          /* bỏ dấu phân cách */

    size_t len = strcspn(p, " \t\n");  /* đo độ dài từ */

    if (len > 0)
        printf("[%.*s]\n", (int)len, p);  /* %.*s in đúng len ký tự */

    p += len;
}

Định dạng %.*s lấy độ chính xác từ tham số, cho phép in một đoạn con của chuỗi mà không cần sao chép hay cắt gì. Đây là công cụ rất tiện khi làm việc với chuỗi.

#Tự cài lại

my-strchr.c

char *my_strchr(const char *s, int c)
{
    char ch = (char)c;

    for (;;) {
        if (*s == ch)
            return (char *)s;      /* tìm thấy, kể cả khi ch là byte 0 */

        if (*s == '\0')
            return NULL;           /* hết chuỗi mà không thấy */

        ++s;
    }
}

char *my_strrchr(const char *s, int c)
{
    char ch = (char)c;
    const char *tim_thay = NULL;

    for (;;) {
        if (*s == ch)
            tim_thay = s;          /* ghi nhớ, nhưng vẫn đi tiếp */

        if (*s == '\0')
            break;

        ++s;
    }

    return (char *)tim_thay;
}

test.c

#include <assert.h>
#include <string.h>

int main(void)
{
    const char *s = "hello";

    assert(my_strchr(s, 'h')  == strchr(s, 'h'));
    assert(my_strchr(s, 'l')  == strchr(s, 'l'));
    assert(my_strchr(s, 'z')  == strchr(s, 'z'));   /* cả hai đều NULL */
    assert(my_strchr(s, '\0') == strchr(s, '\0'));

    assert(my_strrchr(s, 'l')  == strrchr(s, 'l'));
    assert(my_strrchr(s, 'h')  == strrchr(s, 'h'));
    assert(my_strrchr(s, 'z')  == strrchr(s, 'z'));
    assert(my_strrchr(s, '\0') == strrchr(s, '\0'));

    assert(my_strchr("", 'a')  == strchr("", 'a'));
    assert(my_strchr("", '\0') == strchr("", '\0'));

    puts("Tat ca kiem thu deu qua");

    return 0;
}

So sánh trực tiếp hai con trỏ được vì cả hai hàm đều trả về địa chỉ trong cùng một chuỗi. Đây là cách kiểm thử chặt nhất: không chỉ đúng giá trị mà đúng cả vị trí.

Tự làm thử

Dùng strchr và strrchr tìm ký tự trong một đường dẫn, in cả con trỏ lẫn chỉ số.
Cài phan_mo_rong với đủ ba trường hợp biên, thử với năm tên file khác nhau.
Viết hàm đếm số lần xuất hiện của một ký tự, xử lý đúng trường hợp ký tự cần tìm là byte 0.
Cài tach_cap tách dòng cấu hình, thử với dòng không có dấu bằng và dòng có nhiều dấu bằng.
Viết trình tách từ bằng strspn và strcspn, in mỗi từ trên một dòng bằng %.*s.
Cài my_strchr và my_strrchr, chạy bộ kiểm thử so con trỏ với bản chuẩn.

Trình chấm điểm tự động sẽ được bổ sung ở giai đoạn sau. Hiện tại bạn tự chạy thử trên máy.

Tóm tắt

strchr tìm từ đầu, strrchr tìm từ cuối, cả hai trả về con trỏ hoặc NULL.
Đổi con trỏ thành chỉ số bằng phép trừ p - s, kiểu kết quả là ptrdiff_t in bằng %td.
Tìm byte kết thúc luôn thành công, nên kiểm tra NULL không đủ khi ký tự cần tìm có thể bằng 0.
Ghi byte 0 đè lên dấu phân cách là cách tách chuỗi rất hiệu quả, nhưng nó sửa chuỗi gốc.
Cặp strspn và strcspn ghép lại thành một trình phân tích chuỗi đơn giản mà không cần cấp phát gì.