C Language: Hướng dẫn nhập chuỗi an toàn trong C với scanf, fgets và getline

1. Giới thiệu

Ngôn ngữ C là một ngôn ngữ rất quan trọng để học nền tảng lập trình. Trong đó, “nhập chuỗi” là chức năng không thể thiếu khi cần nhận thông tin từ người dùng. Bài viết này sẽ giải thích chi tiết cách nhập chuỗi trong C, đồng thời giới thiệu các kỹ thuật và lưu ý để xử lý dữ liệu một cách an toàn.

Đặc biệt với người mới bắt đầu, việc xử lý chuỗi nhập vào thường dễ gây ra lỗi hoặc rủi ro bảo mật. Vì vậy, bài viết này sẽ bao quát từ các hàm cơ bản đến ví dụ nâng cao, giúp bạn rèn luyện kỹ năng thực hành.

Khi bạn hiểu đúng cách nhập chuỗi và triển khai an toàn trong C, bạn sẽ có thể tiến thêm một bước quan trọng để viết các chương trình nâng cao. Vậy, hãy bắt đầu với nội dung cụ thể.

2. Nhập chuỗi trong C là gì? Giải thích khái niệm cơ bản

Chuỗi là gì?

Trong C, chuỗi được biểu diễn dưới dạng một mảng ký tự. Cuối mỗi chuỗi luôn có một ký tự kết thúc “ ” để đánh dấu điểm dừng. Nhờ đặc điểm này, C có thể xử lý chuỗi mà không cần chỉ định độ dài rõ ràng.

Mối quan hệ giữa chuỗi và mảng

Trong C, chuỗi thực chất là một mảng kiểu ký tự (char). Ví dụ, bạn có thể khai báo chuỗi như sau:

char str[10];  // Bộ nhớ cho chuỗi tối đa 10 ký tự

Trong ví dụ này, một vùng nhớ cho chuỗi tối đa 10 ký tự được cấp phát. Tuy nhiên, 1 ký tự được dành cho ký tự kết thúc “ ”, vì vậy thực tế chỉ có thể chứa 9 ký tự.

Ví dụ về hằng chuỗi

Hằng chuỗi (string literal) là chuỗi được đặt trong dấu nháy kép (“). Ví dụ:

char greeting[] = "Hello";

Trong trường hợp này, greeting sẽ được coi là một mảng có kích thước 6 ký tự (“Hello” + ký tự kết thúc).

Tại sao cần nhập chuỗi?

Trong lập trình, rất nhiều tình huống cần nhập dữ liệu từ người dùng: đăng ký tên, địa chỉ, nhập từ khóa tìm kiếm,… Do đó, hiểu cách xử lý chuỗi một cách an toàn và hiệu quả là rất quan trọng.

3. Các hàm nhập chuỗi cơ bản và ví dụ sử dụng

3-1. Hàm scanf

Cách sử dụng cơ bản của scanf

Hàm scanf được dùng để lấy dữ liệu từ đầu vào chuẩn (bàn phím). Khi nhập chuỗi, ta sử dụng định dạng %s.

Ví dụ mã nguồn:

#include <stdio.h>

int main() {
    char str[50];  // Bộ nhớ cho chuỗi tối đa 50 ký tự
    printf("Nhập chuỗi: ");
    scanf("%s", str);  // Nhập chuỗi từ bàn phím
    printf("Chuỗi đã nhập: %s\n", str);
    return 0;
}

Chương trình này sẽ nhận chuỗi nhập từ người dùng và in ra màn hình.

Lưu ý khi dùng scanf

1. Không xử lý được khoảng trắng:
   Hàm scanf coi khoảng trắng, tab và xuống dòng là ký tự phân cách. Do đó, nếu nhập chuỗi có khoảng trắng thì chỉ lấy đến khoảng trắng đầu tiên.

Ví dụ:
Đầu vào:

Hello World

Đầu ra:

Hello

2. Nguy cơ tràn bộ đệm (buffer overflow):
   Nếu người dùng nhập chuỗi dài hơn kích thước mảng, dữ liệu sẽ ghi đè vùng nhớ khác, có thể gây crash hoặc lỗ hổng bảo mật.

Giải pháp:
Nên dùng các hàm an toàn hơn như fgets (giới thiệu bên dưới).

3-2. Hàm fgets

Cách sử dụng cơ bản của fgets

Hàm fgets cho phép nhập chuỗi an toàn với số ký tự giới hạn. Nó cũng bao gồm cả ký tự xuống dòng, và ngăn chặn được tràn bộ đệm.

Ví dụ mã nguồn:

#include <stdio.h>

int main() {
    char str[50];  // Bộ nhớ tối đa 50 ký tự
    printf("Nhập chuỗi: ");
    fgets(str, sizeof(str), stdin);  // Nhập chuỗi an toàn
    printf("Chuỗi đã nhập: %s", str);
    return 0;
}

Chương trình này cho phép nhập tối đa 50 ký tự và in ra an toàn.

Ưu điểm của fgets

1. Ngăn ngừa tràn bộ đệm: Vì có thể chỉ định kích thước mảng.
2. Xử lý được khoảng trắng: Chuỗi nhập vào có thể chứa khoảng trắng và tab.

Lưu ý khi dùng fgets

1. Xử lý ký tự xuống dòng:
   Chuỗi nhập thường kèm theo ký tự xuống dòng, có thể gây ra dòng trống khi in.

Ví dụ xóa ký tự xuống dòng:

str[strcspn(str, "\n")] = '\0';

2. Dữ liệu thừa trong bộ đệm:
   Khi nhập nhiều hơn giới hạn, phần thừa sẽ nằm lại trong bộ đệm. Có thể dùng fflush(stdin) hoặc getchar() để xóa.

3-3. Nên dùng hàm nào?

Với người mới bắt đầu hoặc trong chương trình thực tế, nên ưu tiên fgets để đảm bảo an toàn.

4. Kỹ thuật thực hành để nhập chuỗi an toàn

4-1. Phòng tránh tràn bộ đệm (Buffer Overflow)

Buffer overflow là gì?

Buffer overflow xảy ra khi dữ liệu nhập vượt quá kích thước mảng được cấp phát, khiến dữ liệu ghi đè sang vùng nhớ khác. Điều này có thể gây crash hoặc tạo ra lỗ hổng bảo mật nghiêm trọng.

Ví dụ nguy hiểm:

char str[10];
scanf("%s", str);  // Không giới hạn độ dài nhập

Nếu nhập nhiều hơn 10 ký tự, chương trình sẽ gặp lỗi tràn bộ đệm.

Giải pháp 1: Dùng fgets

Hàm fgets cho phép chỉ định kích thước mảng, giúp kiểm soát dữ liệu nhập.

Ví dụ an toàn:

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

int main() {
    char str[10];
    printf("Nhập chuỗi: ");
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = '\0';  // Xóa ký tự xuống dòng
    printf("Chuỗi đã nhập: %s\n", str);
    return 0;
}

Trong ví dụ này, chuỗi được giới hạn trong 10 ký tự và xử lý ký tự xuống dòng.

Giải pháp 2: Kiểm tra độ dài chuỗi nhập

Nếu dữ liệu người dùng quá dài, cần cảnh báo hoặc dừng chương trình.

Ví dụ:

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

int main() {
    char str[10];
    printf("Nhập chuỗi (tối đa 9 ký tự): ");
    fgets(str, sizeof(str), stdin);
    if (strlen(str) >= sizeof(str) - 1 && str[strlen(str) - 1] != '\n') {
        printf("Chuỗi quá dài.\n");
        return 1;
    }
    str[strcspn(str, "\n")] = '\0';
    printf("Chuỗi đã nhập: %s\n", str);
    return 0;
}

Ở đây, nếu người dùng nhập quá dài, chương trình sẽ cảnh báo và dừng lại.

4-2. Xử lý lỗi (Error Handling)

Tầm quan trọng của xử lý lỗi

Xử lý lỗi giúp chương trình ổn định hơn. Khi nhập dữ liệu từ người dùng, luôn phải dự phòng trường hợp nhập sai hoặc dữ liệu không hợp lệ.

Giải pháp 1: Cho phép nhập lại

Nếu người dùng nhập sai, yêu cầu nhập lại cho đến khi hợp lệ.

Ví dụ:

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

int main() {
    char str[10];
    int valid = 0;

    while (!valid) {
        printf("Nhập chuỗi (tối đa 9 ký tự): ");
        fgets(str, sizeof(str), stdin);

        if (strlen(str) >= sizeof(str) - 1 && str[strlen(str) - 1] != '\n') {
            printf("Chuỗi quá dài, vui lòng nhập lại.\n");
            while (getchar() != '\n');  // Xóa dữ liệu thừa trong buffer
        } else {
            str[strcspn(str, "\n")] = '\0';
            valid = 1;
        }
    }

    printf("Chuỗi đã nhập: %s\n", str);
    return 0;
}

Ở đây, chương trình sẽ yêu cầu nhập lại nếu người dùng nhập quá dài.

Giải pháp 2: Lọc dữ liệu nhập

Chỉ cho phép chuỗi thỏa mãn điều kiện nhất định (ví dụ: chỉ ký tự chữ và số).

Ví dụ:

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

int isValidInput(const char *str) {
    for (int i = 0; str[i] != '\0'; i++) {
        if (!isalnum(str[i])) {  // Chỉ cho phép ký tự chữ và số
            return 0;
        }
    }
    return 1;
}

int main() {
    char str[50];
    printf("Chỉ nhập ký tự chữ và số: ");
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = '\0';

    if (isValidInput(str)) {
        printf("Chuỗi hợp lệ: %s\n", str);
    } else {
        printf("Dữ liệu không hợp lệ.\n");
    }
    return 0;
}

Trong ví dụ này, chỉ cho phép nhập chuỗi gồm chữ cái và số.

5. Hàm không khuyến nghị và các giải pháp thay thế

5-1. Nguy hiểm của hàm gets

Hàm gets là gì?

Hàm gets từng được dùng để nhập chuỗi từ người dùng. Ví dụ cách sử dụng cơ bản như sau:

Ví dụ mã nguồn:

char str[50];
gets(str);  // Nhập chuỗi từ bàn phím

Thoạt nhìn thì đơn giản, nhưng gets có vấn đề nghiêm trọng.

Nhược điểm của gets

1. Nguy cơ tràn bộ đệm:
   gets không kiểm soát độ dài nhập. Nếu người dùng nhập vượt quá kích thước mảng, dữ liệu sẽ ghi đè vùng nhớ khác.

Ví dụ nguy hiểm:

char str[10];
gets(str);  // Không có giới hạn

Nếu nhập 20 ký tự, bộ nhớ sẽ bị hỏng và có thể làm chương trình crash.

2. Rủi ro bảo mật:
   Hacker có thể lợi dụng lỗi buffer overflow để tấn công, chiếm quyền điều khiển chương trình.
3. Bị loại bỏ trong chuẩn C:
   Đã bị đánh dấu “không khuyến nghị” trong chuẩn C99 và chính thức bị loại bỏ trong C11. Hầu hết compiler hiện nay đều cảnh báo hoặc báo lỗi khi dùng.

5-2. Hàm thay thế an toàn

Sử dụng fgets thay cho gets

Thay vì dùng gets, nên dùng fgets để nhập chuỗi an toàn.

Ví dụ an toàn:

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

int main() {
    char str[50];
    printf("Nhập chuỗi: ");
    fgets(str, sizeof(str), stdin);  // Nhập an toàn
    str[strcspn(str, "\n")] = '\0';  // Xóa ký tự xuống dòng
    printf("Chuỗi đã nhập: %s\n", str);
    return 0;
}

So sánh với scanf

Hàm scanf cũng có thể nhập chuỗi, nhưng như đã giải thích, nó không xử lý được khoảng trắng. Do đó, khi cần nhập chuỗi phức tạp hoặc ưu tiên bảo mật, hãy chọn fgets.

Sử dụng getline

Ngoài fgets, trong môi trường hỗ trợ POSIX, ta có thể dùng getline. Hàm này tự động cấp phát bộ nhớ động, không cần lo kích thước mảng.

Ví dụ:

#include <stdio.h>
#include <stdlib.h>

int main() {
    char *line = NULL;
    size_t len = 0;
    ssize_t read;

    printf("Nhập chuỗi: ");
    read = getline(&line, &len, stdin);  // Nhập động

    if (read != -1) {
        printf("Chuỗi đã nhập: %s", line);
    }

    free(line);  // Giải phóng bộ nhớ
    return 0;
}

Tại sao phải tránh hàm không an toàn?

Trong C, một số hàm cũ không còn an toàn để dùng. Khi xử lý dữ liệu nhập từ bên ngoài, nguy cơ bảo mật rất cao. Vì vậy, việc thay thế gets bằng fgets hoặc getline là bắt buộc.

6. Ví dụ thực tế và phần ứng dụng｜Xử lý nhập chuỗi nhiều dòng

6-1. Nhập nhiều dòng chuỗi

Tổng quan nhập nhiều dòng

Trong một số chương trình, người dùng cần nhập nhiều dòng văn bản và xử lý cùng lúc. Ví dụ như ứng dụng ghi chú, việc nhập nhiều dòng là cần thiết.

Ví dụ 1: Nhập 3 dòng văn bản

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

#define MAX_LINES 3     // Số dòng cần nhập
#define MAX_LENGTH 100  // Số ký tự tối đa mỗi dòng

int main() {
    char lines[MAX_LINES][MAX_LENGTH];  // Mảng 2 chiều để lưu chuỗi

    printf("Hãy nhập %d dòng văn bản:\n", MAX_LINES);

    for (int i = 0; i < MAX_LINES; i++) {
        printf("Dòng %d: ", i + 1);
        fgets(lines[i], sizeof(lines[i]), stdin);
        lines[i][strcspn(lines[i], "\n")] = '\0';  // Xóa ký tự xuống dòng
    }

    printf("\nKết quả nhập:\n");
    for (int i = 0; i < MAX_LINES; i++) {
        printf("Dòng %d: %s\n", i + 1, lines[i]);
    }

    return 0;
}

Giải thích:

1. Dùng mảng 2 chiều: Mỗi dòng là một mảng con.
2. Dùng fgets để nhập an toàn: Giới hạn độ dài và xóa ký tự xuống dòng.
3. Dùng vòng lặp for: Giúp nhập nhiều dòng dễ dàng.

Kết quả chạy:

Nhập 3 dòng văn bản:
Dòng 1: Hello
Dòng 2: World
Dòng 3: C Language

Kết quả nhập:
Dòng 1: Hello
Dòng 2: World
Dòng 3: C Language

6-2. Xử lý chuỗi có khoảng trắng hoặc ký tự đặc biệt

Ví dụ nhập chuỗi có khoảng trắng

Để nhập chuỗi có chứa khoảng trắng, nên dùng fgets.

Ví dụ 2: Nhập chuỗi có khoảng trắng

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

int main() {
    char str[100];  // Bộ nhớ tối đa 100 ký tự

    printf("Nhập một câu: ");
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = '\0';  // Xóa ký tự xuống dòng

    printf("Chuỗi đã nhập: %s\n", str);
    return 0;
}

Điểm cần lưu ý:

• Có thể nhập chuỗi có khoảng trắng hoặc tab.
• Xóa ký tự xuống dòng để tránh dòng trống không mong muốn.

Kết quả chạy:

Nhập một câu: Hello World with spaces
Chuỗi đã nhập: Hello World with spaces

6-3. Xử lý ký tự đặc biệt và escape sequences

Ví dụ nhập ký tự đặc biệt

Trong C, cần xử lý cả ký tự đặc biệt hoặc escape sequences.

Ví dụ 3: Phát hiện ký tự đặc biệt

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

int main() {
    char str[100];
    int specialCharCount = 0;

    printf("Nhập chuỗi: ");
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = '\0';

    for (int i = 0; str[i] != '\0'; i++) {
        if (!isalnum(str[i]) && !isspace(str[i])) {  // Nếu không phải chữ, số, hoặc khoảng trắng
            specialCharCount++;
        }
    }

    printf("Số ký tự đặc biệt: %d\n", specialCharCount);
    return 0;
}

Giải thích:

• isalnum: Kiểm tra có phải chữ hoặc số không.
• isspace: Kiểm tra có phải khoảng trắng không.
• Ký tự khác được tính là đặc biệt.

Kết quả chạy:

Nhập chuỗi: Hello, World! 123
Số ký tự đặc biệt: 2

6-4. Ứng dụng: Chương trình ghi chú đơn giản

Cuối cùng, hãy kết hợp nhập nhiều dòng với ghi file để tạo một ứng dụng ghi chú đơn giản.

Ví dụ 4: Chương trình ghi chú

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

#define MAX_LINES 5
#define MAX_LENGTH 100

int main() {
    char lines[MAX_LINES][MAX_LENGTH];

    printf("Bạn có thể nhập tối đa %d dòng ghi chú.\n", MAX_LINES);
    for (int i = 0; i < MAX_LINES; i++) {
        printf("Dòng %d: ", i + 1);
        fgets(lines[i], sizeof(lines[i]), stdin);
        lines[i][strcspn(lines[i], "\n")] = '\0';
    }

    FILE *file = fopen("memo.txt", "w");
    if (file == NULL) {
        printf("Không thể mở file.\n");
        return 1;
    }

    for (int i = 0; i < MAX_LINES; i++) {
        fprintf(file, "%s\n", lines[i]);
    }

    fclose(file);
    printf("Đã lưu ghi chú.\n");
    return 0;
}

Điểm cần lưu ý:

• Lưu dữ liệu nhập từ người dùng vào file.
• Ví dụ này giúp làm quen với thao tác file trong C.

7. Câu hỏi thường gặp (Q&A)

Q1: Tại sao không nên dùng hàm gets?

A:
Hàm gets nhập chuỗi mà không giới hạn độ dài, dẫn đến nguy cơ tràn bộ đệm. Đây là một lỗ hổng bảo mật nghiêm trọng, vì vậy từ chuẩn C11 trở đi hàm này đã bị loại bỏ. Thay vào đó, nên dùng fgets để an toàn hơn.

Ví dụ thay thế an toàn:

char str[50];
fgets(str, sizeof(str), stdin);
str[strcspn(str, "\n")] = '\0';  // Xóa ký tự xuống dòng

Q2: Tại sao scanf không đọc được chuỗi có khoảng trắng?

A:
Hàm scanf mặc định coi khoảng trắng (space, tab, xuống dòng) là ký tự phân cách, nên chỉ đọc được từ đầu tiên.

Ví dụ:
Đầu vào:

Hello World

Đầu ra:

Hello

Giải pháp:
Dùng fgets để nhập chuỗi có khoảng trắng.

char str[100];
fgets(str, sizeof(str), stdin);
str[strcspn(str, "\n")] = '\0';
printf("Chuỗi đã nhập: %s\n", str);

Q3: Nếu nhập vượt quá giới hạn khi dùng fgets thì sao?

A:
fgets chỉ đọc tối đa số ký tự được chỉ định. Nếu nhập dài hơn, phần thừa sẽ bị bỏ lại trong bộ đệm.

Giải pháp:

1. Hiển thị cảnh báo hoặc cho nhập lại.
2. Dùng getline để cấp phát động (chỉ dùng trong môi trường POSIX).

Ví dụ:

#include <stdio.h>
#include <stdlib.h>

int main() {
    char *line = NULL;
    size_t len = 0;
    printf("Nhập chuỗi: ");
    getline(&line, &len, stdin);
    printf("Chuỗi đã nhập: %s", line);
    free(line);
    return 0;
}

Q4: Làm sao xử lý khi fgets để lại ký tự xuống dòng?

A:
fgets lưu cả ký tự xuống dòng, gây ra dòng trống khi in.

Giải pháp:
Xóa ký tự xuống dòng thủ công.

char str[100];
fgets(str, sizeof(str), stdin);
str[strcspn(str, "\n")] = '\0';
printf("Chuỗi đã nhập: %s\n", str);

Q5: Nếu fgets để lại dữ liệu thừa trong bộ đệm thì sao?

A:
Nếu người dùng nhập quá dài, phần thừa sẽ còn lại trong buffer. Cần dọn sạch buffer bằng getchar.

Ví dụ:

char str[10];
fgets(str, sizeof(str), stdin);

if (strchr(str, '\n') == NULL) {
    int c;
    while ((c = getchar()) != '\n' && c != EOF);  // Đọc bỏ phần còn lại
}

printf("Chuỗi đã nhập: %s\n", str);

Q6: Làm sao chỉ cho phép nhập ký tự chữ và số?

A:
Cần lọc chuỗi và từ chối ký tự không hợp lệ.

Ví dụ:

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

int isValidInput(const char *str) {
    for (int i = 0; str[i] != '\0'; i++) {
        if (!isalnum(str[i])) {
            return 0;
        }
    }
    return 1;
}

int main() {
    char str[50];
    printf("Nhập chuỗi chỉ gồm chữ và số: ");
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = '\0';

    if (isValidInput(str)) {
        printf("Chuỗi hợp lệ: %s\n", str);
    } else {
        printf("Chuỗi không hợp lệ.\n");
    }
    return 0;
}

Q7: Xử lý chuỗi dài vượt quá kích thước buffer thế nào?

A:
Có thể chia nhỏ chuỗi để nhập bằng nhiều lần fgets hoặc dùng getline để cấp phát động.

Ví dụ dùng getline:

#include <stdio.h>
#include <stdlib.h>

int main() {
    char *line = NULL;
    size_t len = 0;
    printf("Nhập chuỗi dài: ");
    getline(&line, &len, stdin);
    printf("Chuỗi đã nhập: %s", line);
    free(line);
    return 0;
}

8. Tổng kết

Trong bài viết này, chúng ta đã tìm hiểu toàn diện từ cơ bản đến nâng cao về nhập chuỗi trong ngôn ngữ C. Bạn đã học được cách sử dụng các hàm nhập chuỗi an toàn, kỹ thuật thực hành và những lưu ý quan trọng để tránh lỗi và rủi ro bảo mật.

1. Hiểu cơ bản về nhập chuỗi

Trong C, chuỗi được biểu diễn bằng mảng ký tự và kết thúc bằng ký tự '\0'. Hiểu rõ điều này giúp bạn nắm vững nền tảng xử lý chuỗi.

2. Đặc điểm của các hàm nhập và cách chọn lựa

• scanf: Không xử lý được khoảng trắng, dễ gây tràn bộ đệm.
• fgets: An toàn, có thể nhập chuỗi có khoảng trắng. Cần xử lý ký tự xuống dòng.
• getline: Cấp phát động, phù hợp nhập chuỗi dài (chỉ có trong môi trường POSIX).

3. Thực hành nhập chuỗi an toàn

Để đảm bảo an toàn, bạn cần:

1. Quản lý kích thước buffer: Không cho phép nhập quá dung lượng.
2. Xử lý ký tự xuống dòng: Loại bỏ ký tự thừa để dữ liệu gọn gàng.
3. Kiểm tra dữ liệu nhập: Lọc dữ liệu không hợp lệ, xử lý lỗi và cho phép nhập lại.

4. Nâng cao kỹ năng qua ví dụ ứng dụng

Chúng ta đã thực hành với các ví dụ nhập nhiều dòng và ghi file. Nhờ đó, bạn đã tiếp cận được các kỹ thuật nâng cao như mảng 2 chiều và quản lý bộ nhớ động.

5. Giải quyết thắc mắc thường gặp

Qua phần Q&A, bạn đã nắm được:

• Vì sao không dùng gets và nên thay thế bằng fgets hoặc getline.
• Cách xử lý chuỗi có khoảng trắng hoặc ký tự đặc biệt.
• Cách xử lý khi nhập vượt quá kích thước buffer hoặc còn sót ký tự xuống dòng.

6. Bước tiếp theo để phát triển kỹ năng

Khi đã nắm vững nhập chuỗi trong C, bạn có thể mở rộng sang:

1. Thư viện xử lý chuỗi: Ứng dụng các hàm như strlen, strcmp, strcpy.
2. Quản lý bộ nhớ động: Sử dụng malloc, realloc để xử lý chuỗi linh hoạt.
3. Xử lý file: Thiết kế chương trình quản lý dữ liệu lớn.
4. Cấu trúc dữ liệu & giải thuật: Áp dụng thuật toán tìm kiếm, sắp xếp chuỗi.

7. Bài tập thực hành gợi ý

Để củng cố kiến thức, bạn có thể thử:

1. Bài tập 1: Hệ thống quản lý danh bạ – Lưu trữ tên và tuổi bằng nhập nhiều dòng.
2. Bài tập 2: Chương trình tìm kiếm từ khóa – Tìm chuỗi phù hợp trong dữ liệu nhập.
3. Bài tập 3: Hệ thống log sử dụng file – Ghi dữ liệu nhập vào file để theo dõi.

Tóm lược

Bài viết đã trình bày toàn diện về nhập chuỗi trong C:

• An toàn: Ưu tiên fgets hoặc getline.
• Quản lý buffer và xử lý lỗi: Tránh tràn bộ đệm, xử lý dữ liệu hợp lệ.
• Ứng dụng thực tế: Nâng cao kỹ năng qua ví dụ nhập nhiều dòng, ghi file và lọc chuỗi.

Nắm vững những kỹ thuật này sẽ giúp bạn phát triển kỹ năng lập trình C lên một tầm cao mới.