การรับข้อมูลข้อความ (String Input) ในภาษา C: คู่มือพื้นฐานและเทคนิคความปลอดภัย

1. บทนำ

2. การรับค่าข้อความในภาษา C คืออะไร? อธิบายแนวคิดพื้นฐาน

ข้อความ (String) คืออะไร?

ความสัมพันธ์ระหว่างข้อความกับอาร์เรย์

char str[10];  // เตรียม buffer สำหรับข้อความได้สูงสุด 10 ตัวอักษร

ตัวอย่างข้อความลิเทอรัล

char greeting[] = "Hello";

เหตุผลที่ต้องใช้การรับค่าข้อความ

3. ฟังก์ชันพื้นฐานในการรับค่าข้อความและตัวอย่างการใช้งาน

3-1. ฟังก์ชัน scanf

การใช้งานพื้นฐานของฟังก์ชัน scanf

#include <stdio.h>

int main() {
    char str[50];  // buffer เก็บข้อความได้สูงสุด 50 ตัวอักษร
    printf("กรุณาป้อนข้อความ: ");
    scanf("%s", str);  // รับข้อความจากอินพุตมาตรฐาน
    printf("ข้อความที่ป้อนคือ: %s\n", str);
    return 0;
}

ข้อควรระวังในการใช้ scanf

1. ไม่สามารถจัดการช่องว่างได้: ฟังก์ชัน scanf จะถือว่าช่องว่าง (space, tab, newline) เป็นตัวแบ่งข้อความ ดังนั้นหากข้อความมีช่องว่าง จะถูกตัดออกกลางคัน

Hello World

Hello

2. เสี่ยงต่อ Buffer Overflow: หากข้อความที่ป้อนยาวเกินขนาด buffer อาจทำให้หน่วยความจำเสียหาย ส่งผลให้โปรแกรมล่มหรือเกิดช่องโหว่ความปลอดภัย

3-2. ฟังก์ชัน fgets

การใช้งานพื้นฐานของฟังก์ชัน fgets

#include <stdio.h>

int main() {
    char str[50];  // buffer เก็บข้อความได้สูงสุด 50 ตัวอักษร
    printf("กรุณาป้อนข้อความ: ");
    fgets(str, sizeof(str), stdin);  // รับข้อความอย่างปลอดภัย
    printf("ข้อความที่ป้อนคือ: %s", str);
    return 0;
}

ข้อดีของ fgets

1. ป้องกัน Buffer Overflow: สามารถกำหนดขนาด buffer ได้
2. รองรับข้อความที่มีช่องว่าง: สามารถรับ space และ tab ได้

ข้อควรระวังของ fgets

1. ปัญหาขึ้นบรรทัดใหม่: ค่าที่รับมาจะมี newline อยู่ท้ายข้อความ อาจทำให้มีการขึ้นบรรทัดเกินมา

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

2. ข้อมูลตกค้างใน buffer: หากใช้ fgets ต่อเนื่องกับการรับข้อมูลอื่น บางครั้งจะมีข้อมูลตกค้าง วิธีแก้คือใช้ fflush(stdin) หรือ getchar() เพื่อล้าง buffer

3-3. ควรเลือกใช้แบบไหน?

4. เทคนิคการเขียนโปรแกรมเพื่อการรับข้อความอย่างปลอดภัย

4-1. การป้องกัน Buffer Overflow

Buffer Overflow คืออะไร?

char str[10];
scanf("%s", str);  // ไม่มีการจำกัดขนาดข้อความที่ป้อน

วิธีแก้ 1: ใช้ fgets

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

int main() {
    char str[10];
    printf("กรุณาป้อนข้อความ: ");
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = '\0';  // ลบ newline
    printf("ข้อความที่ป้อนคือ: %s\n", str);
    return 0;
}

วิธีแก้ 2: ตรวจสอบความยาวอินพุต

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

int main() {
    char str[10];
    printf("กรุณาป้อนข้อความ (ไม่เกิน 9 ตัวอักษร): ");
    fgets(str, sizeof(str), stdin);
    if (strlen(str) >= sizeof(str) - 1 && str[strlen(str) - 1] != '\n') {
        printf("ข้อความที่ป้อนยาวเกินไป\n");
        return 1;  // จบการทำงานด้วย error
    }
    str[strcspn(str, "\n")] = '\0';  // ลบ newline
    printf("ข้อความที่ป้อนคือ: %s\n", str);
    return 0;
}

4-2. การจัดการข้อผิดพลาด (Error Handling)

ความสำคัญของการจัดการข้อผิดพลาด

วิธีแก้ 1: ให้ป้อนใหม่ (Retry)

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

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

    while (!valid) {
        printf("กรุณาป้อนข้อความ (ไม่เกิน 9 ตัวอักษร): ");
        fgets(str, sizeof(str), stdin);

        if (strlen(str) >= sizeof(str) - 1 && str[strlen(str) - 1] != '\n') {
            printf("ข้อความยาวเกินไป กรุณาป้อนใหม่\n");
            while (getchar() != '\n');  // ล้างข้อมูลตกค้างใน buffer
        } else {
            str[strcspn(str, "\n")] = '\0';  // ลบ newline
            valid = 1;  // อินพุตถูกต้อง
        }
    }

    printf("ข้อความที่ป้อนคือ: %s\n", str);
    return 0;
}

วิธีแก้ 2: การกรองอินพุต (Input Filtering)

#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("กรุณาป้อนข้อความ (เฉพาะตัวอักษรหรือตัวเลข): ");
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = '\0';

    if (isValidInput(str)) {
        printf("ข้อความที่ป้อนคือ: %s\n", str);
    } else {
        printf("อินพุตไม่ถูกต้อง\n");
    }

    return 0;
}

5. ฟังก์ชันที่ไม่แนะนำให้ใช้และทางเลือกที่ปลอดภัย

5-1. ความเสี่ยงของฟังก์ชัน gets

ฟังก์ชัน gets คืออะไร?

char str[50];
gets(str);  // รับข้อความจากอินพุตมาตรฐาน

ปัญหาของฟังก์ชัน gets

1. เสี่ยงต่อ Buffer Overflow: ฟังก์ชัน gets ไม่มีการจำกัดความยาวของข้อความที่รับเข้ามา หากข้อความยาวเกิน buffer จะทำให้หน่วยความจำถูกเขียนทับและเกิดปัญหาด้านความปลอดภัย

char str[10];
gets(str);  // ไม่มีการจำกัดขนาดอินพุต

2. ความเสี่ยงด้านความปลอดภัย: Buffer Overflow อาจถูกโจมตีโดยเจตนา (Buffer Overflow Attack) ซึ่งอาจทำให้ระบบถูกยึดครอง
3. ถูกยกเลิกจากมาตรฐาน: ฟังก์ชันนี้ถูกประกาศว่า “ไม่ควรใช้” ตั้งแต่ C99 และถูกลบออกจากมาตรฐาน C11 ทำให้คอมไพเลอร์ส่วนใหญ่แสดง Warning หรือ Error เมื่อใช้งาน

5-2. ฟังก์ชันที่ปลอดภัยแทน gets

ใช้ fgets แทน

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

int main() {
    char str[50];
    printf("กรุณาป้อนข้อความ: ");
    fgets(str, sizeof(str), stdin);  // รับข้อความอย่างปลอดภัย
    str[strcspn(str, "\n")] = '\0';  // ลบ newline
    printf("ข้อความที่ป้อนคือ: %s\n", str);
    return 0;
}

เปรียบเทียบกับ scanf

การใช้ getline

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

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

    printf("กรุณาป้อนข้อความ: ");
    read = getline(&line, &len, stdin);  // จัดสรรหน่วยความจำอัตโนมัติ

    if (read != -1) {
        printf("ข้อความที่ป้อนคือ: %s", line);
    }

    free(line);  // คืนหน่วยความจำ
    return 0;
}

ความสำคัญของการหลีกเลี่ยงฟังก์ชันที่ไม่แนะนำ

6. ตัวอย่างการใช้งานจริงและการประยุกต์｜การรับข้อความหลายบรรทัดและการประมวลผล

6-1. การรับข้อความหลายบรรทัด

ภาพรวมของการรับหลายบรรทัด

ตัวอย่างที่ 1: โปรแกรมรับข้อความ 3 บรรทัด

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

#define MAX_LINES 3     // จำนวนบรรทัดที่รับ
#define MAX_LENGTH 100  // จำนวนตัวอักษรสูงสุดต่อบรรทัด

int main() {
    char lines[MAX_LINES][MAX_LENGTH];  // อาร์เรย์สองมิติสำหรับเก็บข้อความ

    printf("กรุณาป้อนข้อความ %d บรรทัด:\n", MAX_LINES);

    for (int i = 0; i < MAX_LINES; i++) {
        printf("บรรทัดที่ %d: ", i + 1);
        fgets(lines[i], sizeof(lines[i]), stdin);
        lines[i][strcspn(lines[i], "\n")] = '\0';  // ลบ newline
    }

    printf("\nข้อความที่ป้อน:\n");
    for (int i = 0; i < MAX_LINES; i++) {
        printf("บรรทัดที่ %d: %s\n", i + 1, lines[i]);
    }

    return 0;
}

1. ใช้อาร์เรย์สองมิติ: เก็บข้อความแต่ละบรรทัดแยกกัน
2. ใช้ fgets เพื่อความปลอดภัย: จำกัดจำนวนตัวอักษร และลบ newline
3. ใช้ for-loop: รับข้อความหลายบรรทัดได้สะดวก

กรุณาป้อนข้อความ 3 บรรทัด:
บรรทัดที่ 1: Hello
บรรทัดที่ 2: World
บรรทัดที่ 3: C Language

ข้อความที่ป้อน:
บรรทัดที่ 1: Hello
บรรทัดที่ 2: World
บรรทัดที่ 3: C Language

6-2. การประมวลผลข้อความที่มีช่องว่างหรืออักขระพิเศษ

ตัวอย่างการป้อนข้อความที่มีช่องว่าง

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

int main() {
    char str[100];  // buffer สูงสุด 100 ตัวอักษร

    printf("กรุณาป้อนข้อความ: ");
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = '\0';  // ลบ newline

    printf("ข้อความที่ป้อนคือ: %s\n", str);
    return 0;
}

• สามารถรับข้อความที่มีช่องว่างหรือ tab ได้
• ลบ newline เพื่อไม่ให้เกิดการขึ้นบรรทัดเกิน

กรุณาป้อนข้อความ: Hello World with spaces
ข้อความที่ป้อนคือ: Hello World with spaces

6-3. การจัดการอักขระพิเศษและ Escape Sequence

ตัวอย่างข้อความที่มีอักขระพิเศษ

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

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

    printf("กรุณาป้อนข้อความ: ");
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = '\0';  // ลบ newline

    for (int i = 0; str[i] != '\0'; i++) {
        if (!isalnum(str[i]) && !isspace(str[i])) {  // ตรวจจับตัวที่ไม่ใช่อักษรหรือตัวเลข
            specialCharCount++;
        }
    }

    printf("จำนวนอักขระพิเศษ: %d\n", specialCharCount);
    return 0;
}

• ใช้ isalnum เพื่อตรวจสอบว่าเป็นอักษรหรือตัวเลข
• ใช้ isspace เพื่อตรวจสอบว่าเป็นช่องว่าง
• อักขระอื่นจะถูกนับเป็นอักขระพิเศษ

กรุณาป้อนข้อความ: Hello, World! 123
จำนวนอักขระพิเศษ: 2

6-4. ตัวอย่างการประยุกต์: โปรแกรม Notepad แบบง่าย

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

#define MAX_LINES 5
#define MAX_LENGTH 100

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

    printf("คุณสามารถบันทึกได้สูงสุด %d บรรทัด\n", MAX_LINES);
    for (int i = 0; i < MAX_LINES; i++) {
        printf("บรรทัดที่ %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("ไม่สามารถเปิดไฟล์ได้\n");
        return 1;
    }

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

    fclose(file);
    printf("บันทึกข้อความเรียบร้อยแล้ว\n");
    return 0;
}

• บันทึกข้อความที่ผู้ใช้ป้อนลงในไฟล์
• เป็นตัวอย่างพื้นฐานของการทำงานกับไฟล์

7. คำถามที่พบบ่อย (Q&A)

Q1: ทำไมไม่ควรใช้ฟังก์ชัน gets?

char str[50];
fgets(str, sizeof(str), stdin);
str[strcspn(str, "\n")] = '\0';  // ลบ newline

Q2: ทำไม scanf ไม่สามารถรับข้อความที่มีช่องว่างได้?

Hello World

Hello

char str[100];
fgets(str, sizeof(str), stdin);
str[strcspn(str, "\n")] = '\0';
printf("ข้อความที่ป้อนคือ: %s\n", str);

Q3: ถ้าข้อความที่ป้อนยาวเกินขนาด buffer ของ fgets จะทำอย่างไร?

1. แจ้งเตือนผู้ใช้เมื่ออินพุตยาวเกิน
2. ใช้ getline ซึ่งจัดการหน่วยความจำแบบ dynamic (ใช้ได้ในระบบ POSIX)

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

int main() {
    char *line = NULL;
    size_t len = 0;
    printf("กรุณาป้อนข้อความ: ");
    getline(&line, &len, stdin);  // จัดการหน่วยความจำอัตโนมัติ
    printf("ข้อความที่ป้อนคือ: %s", line);
    free(line);
    return 0;
}

Q4: จะจัดการปัญหา newline ที่ fgets เก็บมาด้วยอย่างไร?

char str[100];
fgets(str, sizeof(str), stdin);
str[strcspn(str, "\n")] = '\0';
printf("ข้อความที่ป้อนคือ: %s\n", str);

Q5: ถ้า fgets เหลือข้อมูลตกค้างใน buffer จะทำอย่างไร?

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

if (strchr(str, '\n') == NULL) {
    int c;
    while ((c = getchar()) != '\n' && c != EOF);  // อ่านทิ้งจนกว่าจะเจอ newline
}

printf("ข้อความที่ป้อนคือ: %s\n", str);

Q6: ถ้าต้องการให้รับเฉพาะอักษรหรือตัวเลขทำได้ไหม?

#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("กรุณาป้อนข้อความ (เฉพาะอักษรหรือตัวเลข): ");
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = '\0';

    if (isValidInput(str)) {
        printf("อินพุตถูกต้อง: %s\n", str);
    } else {
        printf("อินพุตไม่ถูกต้อง\n");
    }
    return 0;
}

Q7: ถ้าข้อความยาวมากเกิน buffer จะรับได้อย่างไร?

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

int main() {
    char *line = NULL;
    size_t len = 0;
    printf("กรุณาป้อนข้อความ: ");
    getline(&line, &len, stdin);
    printf("ข้อความที่ป้อนคือ: %s", line);
    free(line);
    return 0;
}

8. สรุป

1. ทำความเข้าใจพื้นฐานการรับข้อความ

2. เลือกใช้ฟังก์ชันรับข้อความอย่างเหมาะสม

• scanf: ใช้งานง่ายแต่ไม่รองรับช่องว่าง และเสี่ยงต่อ Buffer Overflow
• fgets: ปลอดภัย สามารถกำหนดความยาวและรองรับช่องว่าง เพียงแต่ต้องจัดการ newline
• getline: เหมาะสำหรับข้อความยาว และจัดการหน่วยความจำอัตโนมัติ (ใช้ได้เฉพาะระบบ POSIX)

3. ปฏิบัติการเขียนโปรแกรมอย่างปลอดภัย

1. จัดการขนาด buffer: ป้องกันข้อมูลล้น
2. ลบ newline: ทำความสะอาดข้อมูลอินพุต
3. ตรวจสอบอินพุต: กรองค่าที่ไม่ถูกต้อง และรองรับการป้อนใหม่

4. ฝึกทักษะด้วยตัวอย่างประยุกต์

5. คำถามที่พบบ่อยและวิธีแก้ไข

• อันตรายจาก gets และทางเลือกที่ปลอดภัยกว่า
• การจัดการข้อความที่มีช่องว่างหรืออักขระพิเศษ
• การแก้ปัญหา buffer overflow และ newline

6. ก้าวต่อไปในการเรียนรู้

1. ฟังก์ชันจัดการข้อความ: เช่น strlen, strcmp, strcpy
2. การจัดการหน่วยความจำแบบ dynamic: ใช้ malloc และ realloc
3. การทำงานกับไฟล์: อ่าน/เขียนข้อมูลจำนวนมาก
4. โครงสร้างข้อมูลและอัลกอริทึม: เช่น ค้นหาข้อความและการจัดเรียง

7. แบบฝึกหัดแนะนำ

1. แบบฝึกหัด 1: สร้างระบบจัดการรายชื่อ – เก็บชื่อและอายุหลายบรรทัด
2. แบบฝึกหัด 2: โปรแกรมค้นหาคีย์เวิร์ด – ตรวจสอบข้อความที่ผู้ใช้ป้อนว่าเจอหรือไม่
3. แบบฝึกหัด 3: ระบบบันทึก Log – เขียนข้อมูลลงไฟล์เพื่อเรียกใช้ภายหลัง

สรุปสุดท้าย

• ความปลอดภัย: ใช้ fgets หรือ getline แทน gets
• การจัดการ buffer และ error: ตรวจสอบความยาวและกรองอินพุต
• การประยุกต์ใช้งานจริง: เช่น การรับหลายบรรทัดและการทำงานกับไฟล์