Panduan Memotong String di C: Standar, Buatan, Multibyte

1. Pendahuluan

Operasi string dalam bahasa C adalah salah satu keterampilan penting dalam belajar pemrograman. Terutama, pemotongan string (ekstraksi substring) sering digunakan saat memproses data atau melakukan konversi format.

Dalam artikel ini, cara memotong string dalam bahasa C tentang, cara menggunakan fungsi pustaka standar, cara membuat fungsi buatan sendiri, dukungan karakter multibyte (bahasa Jepang), cara membagi string dll akan dijelaskan secara detail. Selain itu, contoh aplikasi dan penanganan error juga akan diperkenalkan, jadi silakan baca sampai akhir.

Apa yang dapat dipelajari dari artikel ini

Dengan membaca artikel ini, Anda dapat memperoleh keterampilan berikut.

• Konsep dasar string dalam bahasa C dan karakter terminasi perannya
• strncpystrchrfungsi pustaka standar lainnya untuk mengekstrak substring
• fungsi buatan
• Mengingat karakter multibyte (Jepang)
• strtok cara memisahkan string
• Metode untuk mengambil karakter sebelum dan sesudah karakter tertentu

Penjelasan akan diberikan dengan contoh kode agar mudah dipahami bahkan oleh pemula.

Mengapa pemotongan string dalam bahasa C penting?

Bahasa C menganggap string sebagai ‘array (array tipe char)’ sehingga tidak dapat dengan mudah mengambil substring seperti bahasa tingkat tinggi lainnya (Python, JavaScript, dll). Oleh karena itu, penting untuk memilih metode yang tepat dalam situasi berikut.

1. Pemrosesan data input

Misalnya, saat menganalisis data seperti log atau file CSV, perlu mengekstrak item tertentu.

2. Mencari kata kunci tertentu

Mencari kata kunci tertentu dalam sebuah string dan mengambil informasi di sekitarnya sangat penting untuk fungsi pencarian dan ekstraksi data.

3. Peningkatan keamanan program

Dengan menggunakan fungsi seperti strncpy, dapat mencegah buffer overflow (penulisan data yang melebihi ukuran buffer). Ini penting untuk menghindari risiko keamanan.

Struktur artikel ini

Artikel ini akan dijelaskan dengan alur berikut.

1. Apa itu string dalam bahasa C? Konsep dasar dan pentingnya karakter terminasi
2. Cara mengekstrak substring dalam bahasa C【Pustaka Standar】
3. Cara mengekstrak substring dalam bahasa C【Versi fungsi buatan sendiri】
4. Metode pemisahan string berdasarkan kode karakter
5. Cara memisahkan string dalam bahasa C
6. Contoh penerapan: Cara mengekstrak karakter sebelum dan sesudah tertentu
7. Ringkasan
8. FAQ

Mari kita mulai dengan melihat secara detail ‘Apa itu string dalam bahasa C? Konsep dasar dan pentingnya karakter terminator’.

2. Apa itu string dalam C-gengo? Konsep dasar dan pentingnya karakter terminasi

2.1 Konsep dasar string dalam C-gengo

String adalah “array char”

Dalam C-gengo, string diperlakukan sebagai array karakter (array tipe char) . Misalnya, kode berikut adalah contoh dasar definisi dan penampilan string.

#include <stdio.h>

int main() {
    char str[] = "Hello, World!"; // Define a string literal as an array
    printf("%s ", str); // Output the string
    return 0;
}

Dalam kode ini, "Hello, World!" disimpan sebagai array tipe char, dan dicetak dengan printf("%s\n", str);.

Struktur internal string

String "Hello" disimpan di memori sebagai berikut.

Dalam C-gengo, karakter khusus yang menunjukkan akhir string (karakter null '\0') secara otomatis ditambahkan di akhir , sehingga panjang string menjadi “jumlah karakter sebenarnya + 1”.

2.2 Pentingnya karakter terminasi (karakter null '

Apa itu karakter null?

')

Masalah ketika tidak ada karakter null

Karakter null ('\0') adalah karakter khusus yang menandakan akhir string. Untuk menangani string dalam C-gengo dengan benar, Anda harus memahami keberadaan karakter null ini.

#include <stdio.h>

int main() {
    char str[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; // Explicitly specify the null terminator
    printf("%s ", str);                            // Display correctly
    return 0;
}

Dalam kode di atas, jika '\0' tidak ada, akhir "Hello" tidak dikenali, sehingga mungkin terjadi perilaku yang tidak diinginkan.

2.3 Cara yang benar mendefinisikan string

Seperti di bawah ini, jika karakter terminasi terlupa , dapat menyebabkan perilaku memori yang tidak normal.

#include <stdio.h>

int main() {
    char str[5] = {'H', 'e', 'l', 'l', 'o'}; // Does not include the null terminator
    printf("%s ", str);                      // May cause unexpected behavior
    return 0;
}

Penyebab error

• printf("%s\n", str); karakter null '\0' sampai menemukan melanjutkan output karakter
• Jika tidak ada, ada kemungkinan data lain di memori akan keluar.

Metode ① Menggunakan literal string

Metode ② Mendefinisikan array secara eksplisit

Cara paling umum untuk mendefinisikan string adalah dengan menggunakan literal string.

char str[] = "Hello";

Dengan metode ini, kompiler C secara otomatis menambahkan karakter null '\0' , sehingga tidak memerlukan penanganan khusus.

2.4 Cara memeriksa ukuran string

Jika Anda mendefinisikan secara manual termasuk '\0', tulis seperti berikut.

char str[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

• Tentukan ukuran karakter, dan penting untuk menambahkan di akhir.
• Jika Anda lupa memasukkan ke dalam , akan terjadi perilaku yang tidak terduga.

Operasi strlen

Untuk mendapatkan panjang string (jumlah karakter), gunakan fungsi strlen.

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

int main() {
    char str[] = "Hello";
    printf("Length of the string: %lu\n", strlen(str)); // Outputs 5 (does not include the null terminator)
    return 0;
}

2.5 Ringkasan

• strlenkarakter null'\0' muncul
• sizeof(str)

3. Cara memotong substring dalam bahasa C 【Bagian pustaka standar】

1. String dalam bahasa C char diwakili oleh array
2. Karakter akhir (karakter null '\0') menunjukkan akhir string, jadi harus selalu disertakan
3. Untuk mendapatkan panjang string, gunakan strlen gunakan
4. Jika tidak mendefinisikan string dengan cara yang tepat, kemungkinan akan terjadi kesalahan yang tidak terduga

3.1 strncpy untuk pengambilan substring

Untuk memotong substring dalam bahasa C, ada cara memanfaatkan pustaka standar. Pada bagian ini, kami menjelaskan cara mengambil sebagian string dengan menggunakan strncpy dan strchr serta fungsi pustaka standar lainnya.

strncpy Struktur dasar

strncpy adalah fungsi yang menyalin sebagian string ke buffer lain.

Contoh penggunaan dasar

char *strncpy(char *dest, const char *src, size_t n);

• dest
• src
• n'\0'

strncpy Poin penting

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

int main() {
    char src[] = "Hello, World!";
    char dest[6];  // Buffer to store the substring

    strncpy(dest, src, 5); // Copy the first 5 characters "Hello"
    dest[5] = '\0';        // Manually add the null terminator

    printf("Substring: %s\n", dest);  // Output "Hello"

    return 0;
}

3.2 strncpy_s untuk penyalinan string aman

1. Karakter null '\0' harus ditambahkan secara manual strncpyn'\0' tidak menambahkan secara otomatis dest[n] = '\0';
2. Perhatikan buffer overflowdestn

strncpy_s Struktur dasar

strncpy_s adalah versi yang meningkatkan keamanan strncpy, sehingga dapat mencegah buffer overflow.

Contoh penggunaan

errno_t strncpy_s(char *dest, rsize_t destsz, const char *src, rsize_t n);

• dest
• destszdest
• src
• n

strncpy_s Keuntungan

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

int main() {
    char src[] = "Hello, World!";
    char dest[6];

    if (strncpy_s(dest, sizeof(dest), src, 5) == 0) {
        dest[5] = '\0';  // Add null terminator just in case
        printf("Substring: %s\n", dest);
    } else {
        printf("Copy error\n");
    }

    return 0;
}

3.3 strchr untuk memotong hingga karakter tertentu

• Ukuran buffer () dapat ditentukan, sehingga dapat menyalin dengan aman.
• destszn

Namun, strncpy_s ditambahkan dalam standar C11, sehingga perlu diingat bahwa tidak dapat digunakan di beberapa lingkungan.

strchr Struktur dasar

strchr memungkinkan Anda menemukan posisi karakter tertentu dan mengambil string hingga bagian tersebut.

Contoh penggunaan

• str
• cchar

Poin penting

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

int main() {
    char str[] = "Hello, World!";
    char *pos = strchr(str, ','); // Find the position of ','

    if (pos != NULL) {
        int length = pos - str; // Calculate the number of characters up to ','
        char result[20];

        strncpy(result, str, length);
        result[length] = '\0'; // Add the null terminator

        printf("Substring: %s\n", result);  // Output "Hello"
    }

    return 0;
}

3.4 strstr untuk pencarian kata kunci dan pemotongan

• strchrmengembalikan alamat c yang pertama kali ditemukan
• pos - strstrncpy

strstr Struktur dasar

strstr berguna untuk mencari substring dan mengambil string setelahnya.

Contoh penggunaan

char *strstr(const char *haystack, const char *needle);

• haystack
• needle

Poin penting

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

int main() {
    char str[] = "Hello, World!";
    char *pos = strstr(str, "World"); // Search for the position of "World"

    if (pos != NULL) {
        printf("Found substring: %s\n", pos);
    } else {
        printf("Substring not found.\n");
    }

    return 0;
}

3.5 Ringkasan

• strstrneedle
• NULLneedlehaystack

4. Cara Memotong Substring di Bahasa C【Bagian Fungsi Buatan】

1. strncpy digunakan untuk menyalin substring dengan aman, namun Anda perlu menambahkan karakter null secara manual.
2. strncpy_s dapat menentukan destsz dan meningkatkan keamanan.
3. strchr jika digunakan, dapat mengambil substring hingga karakter tertentu。
4. strstr jika digunakan, dapat mengambil posisi kata kunci tertentu, dan memotong dari sana.

Dengan memanfaatkan pustaka standar, Anda dapat mengimplementasikan pemrosesan string dalam bahasa C secara sederhana dan aman.

4.1 Manfaat Membuat Fungsi Buatan

Jika memanfaatkan pustaka standar, pemotongan substring dasar dapat dilakukan, tetapi dalam beberapa kasus diperlukan lebih fleksibel . Oleh karena itu, pada bagian ini kami menjelaskan tentang pemotongan substring menggunakan fungsi buatan sendiri.

4.2 Fungsi Dasar Ekstraksi Substring

Dengan menggunakan pustaka standar, Anda dapat menyalin dan mencari substring, tetapi ada masalah berikut.

• strncpy tidak menambahkan karakter null '\0' secara otomatis
• strchr dan strstr hanya dapat melakukan pencarian parsial
• Manipulasi string yang lebih fleksibel sulit

Oleh karena itu, membuat fungsi buatan sendiri yang dapat disesuaikan dengan kebutuhan tertentu menjadi efektif.

Spesifikasi Fungsi

Pertama, buat fungsi dasar yang memotong string dari posisi yang ditentukan.

Kode Implementasi

• Parameter
• const char *source
• int start
• int length
• char *dest
• Isi Proses
• startlengthdest
• '\0'

Poin

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

void substring(const char *source, int start, int length, char *dest) {
    int i;
    for (i = 0; i < length && source[start + i] != '\0'; i++) {
        dest[i] = source[start + i];
    }
    dest[i] = '\0'; // Add null terminator
}

int main() {
    char text[] = "Hello, World!";
    char result[10];

    substring(text, 7, 5, result); // Extract "World"
    printf("Substring: %s\n", result);

    return 0;
}

4.3 Pengambilan substring dinamis menggunakan malloc

• forlength
• '\0'
• dest[i] = '\0'; tambahkan pastikan menempatkan karakter null di akhir

Spesifikasi Fungsi

Pada fungsi di atas, ukuran dest harus dialokasikan sebelumnya. Namun, jika ukuran yang diperlukan dapat dialokasikan secara dinamis, fungsi tersebut menjadi lebih umum.

Kode Implementasi

• Alokasikan memori yang diperlukan
• startlength
• Di pemanggil perlu dilakukan

Poin

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

char *substring_dynamic(const char *source, int start, int length) {
    char *dest = (char *)malloc(length + 1); // +1 for the null terminator
    if (dest == NULL) {
        return NULL; // Memory allocation failed
    }

    int i;
    for (i = 0; i < length && source[start + i] != '\0'; i++) {
        dest[i] = source[start + i];
    }
    dest[i] = '\0';

    return dest;
}

int main() {
    char text[] = "Hello, World!";
    char *result = substring_dynamic(text, 7, 5);

    if (result != NULL) {
        printf("Substring: %s\n", result);
        free(result); // Free allocated memory
    } else {
        printf("Memory allocation failed.\n");
    }

    return 0;
}

4.4 Dukungan Karakter Multibita (Bahasa Jepang)

• mallocmengalokasikan memori secara dinamis
• Setelah digunakan, Anda perlu melepaskan memori dengan .

Implementasi yang Mempertimbangkan Karakter Multibita

Ketika menangani bahasa Jepang (karakter multibita seperti UTF-8), satu karakter tidak selalu 1 byte , sehingga fungsi substring sederhana tidak berfungsi dengan benar.

Kode Implementasi (Dukungan UTF-8)

• mbstowcswchar_t
• wcsncpy
• wcstombs

Poin

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <locale.h>

void substring_utf8(const char *source, int start, int length, char *dest) {
    setlocale(LC_ALL, ""); // Set the locale

    wchar_t wsource[256];
    mbstowcs(wsource, source, 256); // Convert UTF-8 string to wide-character string

    wchar_t wresult[256];
    wcsncpy(wresult, wsource + start, length); // Extract substring in wide characters
    wresult[length] = L'\0';

    wcstombs(dest, wresult, 256); // Convert back to multibyte string
}

int main() {
    char text[] = "こんにちは、世界！"; // UTF-8 string
    char result[20];

    substring_utf8(text, 5, 3, result); // Extract "世界"
    printf("Substring: %s\n", result);

    return 0;
}

4.5 Ringkasan

• setlocale(LC_ALL, "");
• mbstowcs
• Setelah mengambil substring dengan , konversi kembali ke multibyte dengan .

5. Metode Pemotongan String per Kode Karakter

1. substring Jika Anda membuatnya sendiri, Anda dapat mengambil substring secara fleksibel。
2. Pengalokasian memori dinamis (malloc) memungkinkan pengambilan substring dengan ukuran variabel。
3. Jika menangani karakter multibyte (Jepang), mbstowcs / wcstombs gunakan.

Jika pustaka standar seperti strncpy atau strchr sulit diatasi, dengan membuat fungsi buatan sendiri, Anda dapat membuat pemrosesan string di bahasa C menjadi lebih kuat.

5.1 ASCII（karakter 1 byte）dalam kasus

Dalam C Gengo, Jika tidak memperhatikan perbedaan kode karakter, proses pemotongan string mungkin tidak berfungsi dengan benar hal ini dapat terjadi. Terutama, ketika menangani karakter multibita seperti bahasa Jepang (UTF-8, Shift_JIS, EUC-JP, dll.), karena 1 karakter ≠ 1 byte, fungsi sederhana seperti strncpy atau substring tidak dapat memproses dengan tepat.

Pada bagian ini, Metode Pemotongan String per Kode Karakter akan dijelaskan secara detail.

Pengambilan substring dasar

Contoh Implementasi

Karakter ASCII 1 karakter = 1 byte sehingga, strncpy atau substring dapat diproses dengan mudah.

5.2 UTF-8（karakter multibita）dalam kasus

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

void substring_ascii(const char *source, int start, int length, char *dest) {
    strncpy(dest, source + start, length);
    dest[length] = '\0'; // Add null terminator
}

int main() {
    char text[] = "Hello, World!";
    char result[6];

    substring_ascii(text, 7, 5, result); // Extract "World"
    printf("Substring: %s\n", result);

    return 0;
}

Poin

• Jika teks ASCII (hanya alfanumerik) maka strncpy cukup dapat menangani
• '\0'Selalu tambahkan (karakter null)

Karakteristik UTF-8

Metode Penanganan yang Benar

Pada UTF-8, jumlah byte per karakter 1-4 byte yang berubah-ubah, sehingga penggunaan sederhana strncpy dapat menyebabkan pemotongan karakter di tengah.

Pengambilan substring yang mendukung UTF-8

Dalam C Gengo, untuk memproses UTF-8 dengan aman, mbstowcs digunakan untuk mengonversi ke string lebar ( wchar_t ) dan metode mengambil substring disarankan.

5.3 Shift_JIS（karakter multibita）dalam kasus

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

void substring_utf8(const char *source, int start, int length, char *dest) {
    setlocale(LC_ALL, ""); // Set the locale

    wchar_t wsource[256];
    mbstowcs(wsource, source, 256); // Convert multibyte string to wide-character string

    wchar_t wresult[256];
    wcsncpy(wresult, wsource + start, length); // Get the substring
    wresult[length] = L'\0';

    wcstombs(dest, wresult, 256); // Convert wide-character string back to multibyte
}

int main() {
    char text[] = "こんにちは、世界！"; // UTF-8 string
    char result[20];

    substring_utf8(text, 5, 3, result); // Extract "世界"
    printf("Substring: %s\n", result);

    return 0;
}

Poin

• setlocale(LC_ALL, "");
• mbstowcswchar_twcsncpy
• wcstombs

Karakteristik Shift_JIS

Pengambilan substring yang mendukung Shift_JIS

Pada Shift_JIS, 1 karakter dapat menjadi 1 byte atau 2 byte sehingga penggunaan sederhana strncpy dapat menyebabkan karakter rusak.

Implementasi pada Shift_JIS

Bahkan dalam kasus Shift_JIS, metode mengonversi ke string lebar dan memprosesnya disarankan.

5.4 EUC-JP（karakter multibita）dalam kasus

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

void substring_sjis(const char *source, int start, int length, char *dest) {
    setlocale(LC_ALL, "Japanese"); // Set locale to handle Shift_JIS

    wchar_t wsource[256];
    mbstowcs(wsource, source, 256); // Convert multibyte string (Shift_JIS) to wide-character string

    wchar_t wresult[256];
    wcsncpy(wresult, wsource + start, length); // Extract substring
    wresult[length] = L'\0';

    wcstombs(dest, wresult, 256); // Convert wide-character string back to multibyte (Shift_JIS)
}

int main() {
    char text[] = "こんにちは、世界！"; // Shift_JIS string (depending on environment)
    char result[20];

    substring_sjis(text, 5, 3, result); // Extract "世界"
    printf("Substring: %s\n", result);

    return 0;
}

Poin

• Untuk memproses Shift_JIS dengan benar, Anda perlu diatur.
• mbstowcswcstombs

Karakteristik EUC-JP

Pengambilan substring yang mendukung EUC-JP

EUC-JP, seperti Shift_JIS, karena jumlah byte per karakter berbeda, diperlukan proses konversi yang menggunakan karakter lebar .

5.5 Kesimpulan

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

void substring_eucjp(const char *source, int start, int length, char *dest) {
    setlocale(LC_ALL, "ja_JP.eucJP"); // Set locale to handle EUC-JP

    wchar_t wsource[256];
    mbstowcs(wsource, source, 256); // Convert multibyte string (EUC-JP) to wide-character string

    wchar_t wresult[256];
    wcsncpy(wresult, wsource + start, length); // Extract substring
    wresult[length] = L'\0';

    wcstombs(dest, wresult, 256); // Convert wide-character string back to multibyte (EUC-JP)
}

int main() {
    char text[] = "こんにちは、世界！"; // EUC-JP string (depending on environment)
    char result[20];

    substring_eucjp(text, 5, 3, result); // Extract "世界"
    printf("Substring: %s\n", result);

    return 0;
}

Poin

• setlocale(LC_ALL, "ja_JP.eucJP");
• mbstowcswcstombs

6. Cara Memisahkan String dengan Bahasa C

• Jika hanya karakter ASCII strncpy OK
• Jika menggunakan UTF-8, Shift_JIS, EUC-JP gunakan mbstowcs / wcstombs gunakan
• sesuai dengan lingkungan setlocale(LC_ALL, \"...\"); mengatur dengan tepat

6.1 Memisahkan String dengan Menggunakan strtok

Proses pemisahan string, analisis data CSV, pemrosesan argumen baris perintah, analisis data log dll, diperlukan di banyak situasi. Dalam Bahasa C, ada cara menggunakan fungsi pustaka standar seperti strtok dan strtok_r, atau membuat fungsi buatan sendiri.

Pada bagian ini, kami akan menjelaskan secara detail tentang cara memisahkan string dengan karakter pemisah tertentu.

Syntax Dasar

strtok adalah fungsi yang memisahkan string berdasarkan karakter pemisah yang ditentukan (delimiter).

Contoh Penggunaan: Memisahkan string dengan koma ,

char *strtok(char *str, const char *delim);

• str
• delim
• nilai kembali
• Catatanstrtok'\0'

Hasil Eksekusi

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


int main() {
    char str[] = "apple,banana,orange,grape"; // String to be split
    char *token = strtok(str, ",");            // Get the first token

    while (token != NULL) {
        printf("Token: %s\n", token);
        token = strtok(NULL, ",");             // Get the next token
    }

    return 0;
}

Catatan tentang strtok

token: apple
token: banana
token: orange
token: grape

6.2 Memisahkan String yang Thread-Safe dengan Menggunakan strtok_r

1. Ubah string asli

• strtok karakter pemisah diubah menjadi '\0'

1. tidak thread-safe

• strtok variabel statis global secara internal

Syntax Dasar

strtok_r adalah versi thread-safe dari strtok, dan menyimpan status ke dalam saveptr sehingga dapat digunakan dengan aman di lingkungan multithread.

Contoh Penggunaan: Memisahkan string dengan spasi

char *strtok_r(char *str, const char *delim, char **saveptr);

• str
• delim
• saveptr

Keuntungan strtok_r

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

int main() {
    char str[] = "Hello World from C"; // String to be split
    char *token;
    char *saveptr; // Pointer to store internal state

    token = strtok_r(str, " ", &saveptr); // Get the first token
    while (token != NULL) {
        printf("Token: %s\n", token);
        token = strtok_r(NULL, " ", &saveptr); // Get the next token
    }

    return 0;
}

6.3 Memisahkan String dengan Fungsi Buatan Sendiri (tanpa menggunakan strtok)

• thread-safe
• mampu memproses beberapa string secara paralel

Spesifikasi Fungsi Buatan Sendiri

strtok mengubah string asli, sehingga memungkinkan untuk membuat fungsi buatan sendiri yang memisahkan string tanpa mengubahnya.

Kode Implementasi

• input
• const char *source
• const char delim
• char tokens[][50]
• pemrosesan
• source
• delimtokens

Hasil Eksekusi

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

void split_string(const char *source, char delim, char tokens[][50], int *count) {
    int i = 0, j = 0, token_index = 0;

    while (source[i] != '\0') {
        if (source[i] == delim) {
            tokens[token_index][j] = '\0';
            token_index++;
            j = 0;
        } else {
            tokens[token_index][j] = source[i];
            j++;
        }
        i++;
    }
    tokens[token_index][j] = '\0';
    *count = token_index + 1;
}

int main() {
    char text[] = "dog,cat,bird,fish";
    char tokens[10][50]; // Can store up to 10 words
    int count;

    split_string(text, ',', tokens, &count);

    for (int i = 0; i < count; i++) {
        printf("Token: %s\n", tokens[i]);
    }

    return 0;
}

Poin Penting

Token: dog
Token: cat
Token: bird
Token: fish

6.4 Aplikasi Pemisahan String (Pengolahan Data CSV)

• source
• tokens

Contoh Analisis Data CSV

Data CSV (dipisahkan dengan koma) dapat dianalisis menggunakan strtok.

Hasil Eksekusi

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

int main() {
    char csv[] = "Alice,24,Female\nBob,30,Male\nCharlie,28,Male"; // CSV data
    char *line = strtok(csv, "\n"); // Process line by line

    while (line != NULL) {
        char *name = strtok(line, ",");
        char *age = strtok(NULL, ",");
        char *gender = strtok(NULL, ",");

        printf("Name: %s, Age: %s, Gender: %s\n", name, age, gender);

        line = strtok(NULL, "\n");
    }

    return 0;
}

6.5 Ringkasan

Name: Alice, Age: 24, Gender: Female
Name: Bob, Age: 30, Gender: Male
Name: Charlie, Age: 28, Gender: Male

Kesimpulan

7. Contoh aplikasi: Cara mengekstrak sebelum dan sesudah karakter tertentu

• Jika pembagian sederhana strtok
• Jika multithreading strtok_r
• Jika Anda tidak ingin mengubah aslinya, gunakan fungsi buatan sendiri
• Juga dapat diterapkan pada analisis data CSV

Pada bagian berikutnya, kami akan menjelaskan secara detail tentang 「Contoh Aplikasi: Cara Mengekstrak Karakter Sebelum dan Sesudah Karakter Tertentu」.

7.1 strchr untuk mengambil string sebelum karakter tertentu

Dalam pemrosesan string, mengekstrak sebelum dan sesudah karakter atau kata kunci tertentu sering diperlukan. Misalnya, kasus seperti berikut dapat dipertimbangkan.

• Dapatkan hanya bagian domain dari URL
• Ekstrak nama file dari jalur file
• Mendapatkan string sebelum dan sesudah tag atau simbol tertentu

Dalam bahasa C, strchr dan strstr dapat digunakan untuk mewujudkan proses ini. Selain itu, bila diperlukan pemrosesan yang lebih fleksibel, membuat fungsi buatan sendiri juga efektif.

sintaks dasar

strchr dapat digunakan untuk menentukan posisi karakter tertentu (yang pertama kali ditemukan).

contoh penggunaan: mengambil nama file dari path file

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

• str
• cchar

strchr mengembalikan alamatnya bila menemukan c.

hasil eksekusi

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

void get_filename(const char *path, char *filename) {
    char *pos = strrchr(path, '/'); // Search for the last '/'

    if (pos != NULL) {
        strcpy(filename, pos + 1); // Copy from the character after '/'
    } else {
        strcpy(filename, path); // If no '/', copy the whole path
    }
}

int main() {
    char path[] = "/home/user/documents/report.txt";
    char filename[50];

    get_filename(path, filename);
    printf("Filename: %s\n", filename);

    return 0;
}

poin

Filename: report.txt

7.2 strstr untuk mengambil string setelah kata kunci tertentu

• strrchrkarakter tertentu yang muncul terakhir ( / ) posisi dapat diambil
• pos + 1hanya nama file yang dapat diperoleh

sintaks dasar

strstr dapat digunakan untuk mencari string tertentu (kata kunci) dan mengambil string setelah posisinya.

contoh penggunaan: mengambil domain dari URL

char *strstr(const char *haystack, const char *needle);

• haystack
• needle

strstr mengembalikan alamat posisi bila menemukan needle.

hasil eksekusi

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

void get_domain(const char *url, char *domain) {
    char *pos = strstr(url, "://"); // Search for the position of "://"

    if (pos != NULL) {
        strcpy(domain, pos + 3); // Copy from the character after "://"
    } else {
        strcpy(domain, url); // If "://" is not found, copy the entire string
    }
}

int main() {
    char url[] = "https://www.example.com/page.html";
    char domain[50];

    get_domain(url, domain);
    printf("Domain part: %s\n", domain);

    return 0;
}

poin

Domain part: www.example.com/page.html

7.3 strchr untuk memisahkan bagian sebelum dan sesudah karakter tertentu

• strstr"https://""http://""//"
• pos + 3://

contoh penggunaan: memisahkan nama pengguna dan domain dari alamat email

strchr dapat dimanfaatkan untuk memisahkan dan mengambil string sebelum dan sesudah karakter tertentu.

hasil eksekusi

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

void split_email(const char *email, char *username, char *domain) {
    char *pos = strchr(email, '@'); // Search for the position of '@'

    if (pos != NULL) {
        strncpy(username, email, pos - email); // Copy the part before '@'
        username[pos - email] = '\0';          // Add null terminator
        strcpy(domain, pos + 1);               // Copy the part after '@'
    }
}

int main() {
    char email[] = "user@example.com";
    char username[50], domain[50];

    split_email(email, username, domain);
    printf("Username: %s\n", username);
    printf("Domain: %s\n", domain);

    return 0;
}

poin

Username: user
Domain: example.com

7.4 Aplikasi: Mengekstrak atribut tertentu dalam tag HTML

• strchr'@'
• strncpy'@' bagian sebelum, salin, dan tambahkan karakter null
• strcpy'@' bagian setelahnya salin

contoh penggunaan: <a href="URL"> untuk mengambil URL

Jika ingin mengambil atribut tertentu dari dalam tag HTML, strstr dapat dimanfaatkan.

hasil eksekusi

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

void get_href(const char *html, char *url) {
    char *start = strstr(html, "href=\""); // Search for the position of href="
    if (start != NULL) {
        start += 6; // Move past href="
        char *end = strchr(start, '"'); // Search for the next "
        if (end != NULL) {
            strncpy(url, start, end - start);
            url[end - start] = '\0'; // Add null terminator
        }
    }
}

int main() {
    char html[] = "<a href=\"https://example.com\">Click Here</a>";
    char url[100];

    get_href(html, url);
    printf("Extracted URL: %s\n", url);

    return 0;
}

poin

Extracted URL: https://example.com

7.5 Ringkasan

• strstr"href=\"
• strchr"

Kesimpulan

8. Ringkasan

• strchr dan strstr ketika memanfaatkan, dapat dengan mudah memperoleh sebelum dan sesudah karakter/kata kunci tertentu
• Pengolahan jalur file, analisis URL, pemisahan alamat email, dan banyak lagi, sangat berguna dalam banyak situasi
• Juga dapat diterapkan pada proses lanjutan seperti web scraping

8.1 Meninjau Artikel

Dalam artikel ini, tentang cara memotong string dalam C Gengo secara detail dari dasar hingga aplikasi. Di sini, kami meninjau poin penting setiap bagian dan menyusun metode optimal berdasarkan kegunaan.

8.2 Metode Optimal Berdasarkan Kegunaan

1. Memotong Substring

2. Membagi String

3. Mengambil Sebelum dan Sesudah Karakter Tertentu

8.3 Hal-hal yang Perlu Diperhatikan dalam Pemrosesan String C Gengo

1. Menegakkan Pengelolaan Terminasi Null '

Contoh Penyalinan String Aman

'

2. Waspadai Buffer Overflow

Dalam pemrosesan string C Gengo, mengelola karakter terminasi ‘\0’ dengan tepat adalah hal yang paling penting. Khususnya saat menggunakan strncpy atau strchr, perhatikan untuk menambahkan karakter null secara manual.

3. Gunakan mbstowcs untuk Memproses Karakter Multibyte

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

int main() {
    char src[] = "Hello, World!";
    char dest[6];

    strncpy(dest, src, 5);
    dest[5] = '\0'; // Add null terminator for safety

    printf("Substring: %s\n", dest);

    return 0;
}

4. Pengelolaan Ukuran Buffer

Dalam operasi string C Gengo, perlu diimplementasikan dengan hati-hati agar tidak mengakses di luar batas array. Khususnya saat menggunakan strncpy, penting untuk mengontrol jumlah byte yang disalin.

Contoh Penyalinan String Aman

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

int main() {
    char src[] = "Hello, World!";
    char dest[6];

    strncpy(dest, src, sizeof(dest) - 1);
    dest[5] = '\0'; // Explicitly add null terminator

    printf("Substring: %s\n", dest);
    return 0;
}

8.4 Menuju Pembelajaran Lebih Lanjut

Jika menangani karakter multibyte seperti UTF-8 atau Shift_JIS, fungsi strncpy atau strlen tidak berfungsi dengan benar.

Oleh karena itu, ketika menangani karakter multibyte, disarankan untuk mengonversinya terlebih dahulu ke string lebar menggunakan mbstowcs, lalu memprosesnya dengan tepat.

#include <stdio.h>
#include <wchar.h>
#include <locale.h>

int main() {
    setlocale(LC_ALL, ""); // Set the locale

    char text[] = "こんにちは、世界！"; // UTF-8
    wchar_t wtext[256];

    mbstowcs(wtext, text, 256); // Convert to wide-character string

    printf("Converted wide-character string: %ls\n", wtext);

    return 0;
}

Topik untuk Memperdalam Pembelajaran

Dalam pemrosesan string, penting untuk menghitung ukuran memori yang diperlukan sebelumnya dan mencegah overflow buffer. Khususnya saat menggunakan malloc untuk mengalokasikan memori dinamis, pastikan ukuran yang tepat.

8.5 Ringkasan

Pemrosesan string C Gengo adalah keterampilan penting untuk meningkatkan keamanan dan keterbacaan program. Berdasarkan isi artikel ini, mempelajari topik berikut akan memungkinkan pemrosesan string yang lebih canggih.

Topik untuk Memperdalam Pembelajaran

1. Ekspresi reguler (regex)
2. Operasi file（pengolahan string menggunakan fgets, fscanf）
3. Manajemen memori (pengolahan string dinamis menggunakan malloc, realloc)
4. Analisis data (JSON, XML parsing methods)

8.5 Ringkasan

1. String dalam bahasa C dikelola sebagai array char, sehingga penanganan karakter akhir '\0' penting
2. Untuk memotong substring, gunakan strncpy, substring(), malloc gunakan
3. Untuk memisahkan string, strtok / strtok_r / gunakan fungsi buatan
4. Jika ingin mengambil karakter sebelum dan sesudah tertentu, strchr, strstr gunakan
5. Jika menangani karakter multibyte (Jepang), mbstowcs gunakan
6. Berusahalah melakukan pengolahan string yang aman, dan perhatikan buffer overflow.

Jika Anda memanfaatkan isi artikel ini, pemrosesan string yang praktis dalam C Gengo menjadi memungkinkan. Setelah memahami fungsi dasar, tantang diri Anda dengan fungsi buatan sendiri dan pemrosesan lanjutan, sehingga dapat menulis kode yang lebih efisien!