Chuỗi trong C: mảng char, ký tự kết thúc null và ví dụ

Hầu hết các ngôn ngữ cho bạn một kiểu string tự biết độ dài của nó. C thì không. Trong C, chuỗi (string) chỉ là một mảng char kèm theo một quy tắc: sau văn bản là một byte có giá trị 0, viết là '\0' và gọi là ký tự kết thúc null (null terminator). Mọi thứ khác về chuỗi trong C đều xuất phát từ quy ước duy nhất đó.

Chuỗi là mảng char cộng '\0'

Khai báo một chuỗi bằng cách khởi tạo mảng char từ một chuỗi hằng:

#include <stdio.h>

int main(void) {
    char name[] = "Ada";

    printf("%s\n", name);
    printf("%c %c %c\n", name[0], name[1], name[2]);
    printf("last byte is %d\n", name[3]);
    return 0;
}

Mảng này gồm bốn byte, không phải ba:

name:  +-----+-----+-----+------+
       | 'A' | 'd' | 'a' | '\0' |
       +-----+-----+-----+------+
index:    0     1     2     3

sizeof(name) là 4. Trình biên dịch đếm các ký tự, cộng thêm một cho ký tự kết thúc và tự đặt kích thước mảng cho bạn. Byte thừa đó là lý do char name[3] = "Ada"; là một bug chực chờ xảy ra: văn bản vừa nhưng ký tự kết thúc thì không, nên không đoạn code nào phía sau biết chuỗi kết thúc ở đâu.

Khi bạn muốn có chỗ để thay đổi nội dung về sau, hãy tự ghi kích thước và chừa dư:

char name[32] = "Ada";   /* 3 characters, a terminator, 28 bytes spare */

Các byte không dùng được phần khởi tạo điền bằng 0, hoàn toàn vô hại.

Vì sao ký tự kết thúc quan trọng

Không hàm C nào nhận độ dài. printf("%s", s) chỉ được đưa một địa chỉ và cứ thế đi tới in từng byte cho đến khi gặp '\0'. Vì vậy một mảng char không có ký tự kết thúc thì không phải là chuỗi, và coi nó là chuỗi sẽ đọc bất cứ vùng nhớ nào nằm ngay sau đó.

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

int main(void) {
    char good[4] = {'A', 'd', 'a', '\0'};
    char letters[3] = {'A', 'd', 'a'};   /* no terminator - NOT a string */

    printf("good:   %s (length %zu)\n", good, strlen(good));
    printf("sizeof letters = %zu\n", sizeof letters);
    /* printf("%s", letters) would read past the end - don't. */
    return 0;
}

Quy tắc cần nhớ: sizeof cho bạn vùng lưu trữ, strlen cho bạn văn bản. Với char buf[32] = "Ada", sizeof buf là 32 và strlen(buf) là 3. Chúng trả lời hai câu hỏi khác nhau, và nhầm lẫn giữa chúng là một trong những bug phổ biến nhất trong C.

Chuỗi hằng và mảng char

Hai dòng này trông giống nhau nhưng hoạt động rất khác nhau:

char  a[] = "hello";   /* an array you own, initialized from the literal */
char *p   = "hello";   /* a pointer aimed at the literal itself */

a là mảng 6 byte chứa bản sao riêng của văn bản. Bạn có thể sửa nó. p trỏ vào vùng dữ liệu chuỗi chỉ đọc của chương trình; chuỗi hằng được dùng chung, và ghi qua p là undefined behavior, thường làm chương trình crash lúc chạy chứ không báo lỗi lúc biên dịch.

#include <stdio.h>

int main(void) {
    char a[] = "hello";
    const char *p = "hello";

    a[0] = 'H';          /* fine - a is your own array */
    printf("%s\n", a);

    /* p[0] = 'H'; would be undefined behavior */
    printf("%s\n", p);
    return 0;
}

Hãy viết const char * mỗi khi một con trỏ trỏ tới chuỗi hằng. Khi đó trình biên dịch sẽ từ chối lệnh ghi ngay lúc biên dịch thay vì để nó thành một lần crash. Chọn giữa hai cách thực chất là câu hỏi về con trỏ và mảng, được trình bày trong trang con trỏ và mảng.

Thêm một khác biệt đáng biết: sizeof a là 6, nhưng sizeof p là kích thước của một con trỏ (8 trên hầu hết hệ thống), bất kể văn bản dài bao nhiêu.

In và đọc chuỗi

%s in một chuỗi; %c in một ký tự.

#include <stdio.h>

int main(void) {
    char city[] = "Lisbon";

    printf("City: %s\n", city);
    printf("Initial: %c\n", city[0]);
    printf("Padded: [%10s]\n", city);
    printf("Cut to 3: [%.3s]\n", city);
    return 0;
}

Với đầu vào, hãy tránh hẳn gets: hàm này đã bị loại khỏi ngôn ngữ vì không thể dùng an toàn. Hãy dùng fgets, hàm nhận kích thước buffer và sẽ không ghi tràn:

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

int main(void) {
    char line[64];

    printf("Type your name: ");
    if (fgets(line, sizeof line, stdin) != NULL) {
        line[strcspn(line, "\n")] = '\0';   /* drop the trailing newline */
        printf("Hello, %s!\n", line);
    }
    return 0;
}

fgets giữ lại ký tự xuống dòng bạn đã nhấn, điều gần như không bao giờ bạn muốn có trong chuỗi. Dòng strcspn tìm '\n' đầu tiên và ghi đè nó bằng ký tự kết thúc: một cách cắt bỏ gọn gàng và chuẩn mực.

Duyệt chuỗi từng ký tự

Vì điểm kết thúc được đánh dấu chứ không được đếm, vòng lặp (loop) chuẩn sẽ kiểm tra chính ký tự đó:

#include <stdio.h>

int main(void) {
    char text[] = "banana";
    int count = 0;

    for (int i = 0; text[i] != '\0'; i++) {
        if (text[i] == 'a') {
            count++;
        }
    }

    printf("'a' appears %d times\n", count);
    return 0;
}

Điều kiện text[i] != '\0' thường được viết gọn thành text[i], vì '\0' bằng 0 và do đó là false. Cả hai đều đúng; dạng tường minh dễ đọc hơn khi bạn đang học.

Bạn cũng có thể duyệt bằng con trỏ thay vì chỉ số, cách này cũng chuẩn mực không kém trong C:

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

int main(void) {
    char text[] = "Make It Loud";

    for (char *p = text; *p != '\0'; p++) {
        *p = (char)toupper((unsigned char)*p);
    }

    printf("%s\n", text);
    return 0;
}

Ép kiểu sang unsigned char trước khi gọi toupper không phải để trang trí: các hàm trong <ctype.h> có hành vi không xác định với giá trị âm, và một char thường có thể mang giá trị âm với các byte lớn hơn 127.

Không thể sao chép chuỗi bằng =

Đây là bức tường mà người mới nào cũng đụng phải:

char a[10];
a = "hello";        /* error: assignment to expression with array type */

char b[10] = "hi";
char c[10];
c = b;              /* error - same reason */

Tên mảng không phải là một giá trị có thể sửa, nên = không có gì để làm. Chỗ duy nhất cách viết tắt hoạt động là khởi tạo khi khai báo, một thao tác khác do trình biên dịch thực hiện.

Để sao chép lúc chạy, hãy sao chép các byte bằng strcpy trong <string.h>:

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

int main(void) {
    char source[] = "hello";
    char dest[16];

    strcpy(dest, source);
    strcat(dest, " there");

    printf("%s (%zu chars)\n", dest, strlen(dest));
    return 0;
}

Cùng lý do đó giải thích vì sao == không so sánh chuỗi. if (a == b) so sánh hai địa chỉ, nên cho ra false với hai mảng khác nhau dù chứa văn bản giống hệt. Hãy dùng strcmp(a, b) == 0. Cả hai hàm và các phiên bản an toàn hơn của chúng được trình bày trong trang hàm xử lý chuỗi.

Mảng chuỗi

Một danh sách chuỗi có thể là mảng con trỏ (cho văn bản cố định mà bạn chỉ đọc) hoặc mảng char hai chiều (khi từng phần tử cần sửa được):

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

int main(void) {
    const char *fruits[] = {"apple", "kiwi", "banana"};
    int n = (int)(sizeof fruits / sizeof fruits[0]);

    for (int i = 0; i < n; i++) {
        printf("%-8s %zu\n", fruits[i], strlen(fruits[i]));
    }

    char editable[3][16] = {"apple", "kiwi", "banana"};
    strcpy(editable[1], "pear");
    printf("changed: %s\n", editable[1]);
    return 0;
}

Mảng con trỏ lưu ba địa chỉ trỏ vào các chuỗi hằng chỉ đọc: gọn nhẹ nhưng không sửa được. Dạng char[3][16] dành 48 byte trong vùng nhớ của riêng bạn, nên từng hàng đều có thể ghi lại.

Lỗi thường gặp

• Quên byte của ký tự kết thúc. char s[5] = "hello" không còn chỗ cho '\0'. Hãy đặt kích thước bằng strlen + 1.
• Dùng sizeof khi ý bạn là strlen. sizeof trên con trỏ cho ra kích thước con trỏ, không phải độ dài văn bản.
• Ghi qua một char * trỏ tới chuỗi hằng. Hãy khai báo những con trỏ như vậy là const char *.
• So sánh bằng ==. Phép này so sánh địa chỉ. Hãy dùng strcmp.
• Đọc bằng scanf("%s", buf). Cách này không giới hạn kích thước và dễ dàng ghi tràn; nên dùng fgets.