Gabay sa Pagputol ng String sa C | Standard Custom Multi-byte

1. Pambungad

Sa C Gengo, ang paghawak ng mga string ay isa sa mga mahalagang kasanayan sa pag-aaral ng programming. Lalo na, pagputol ng string (pagkuha ng bahagi ng string) ay madalas gamitin kapag nagpoproseso ng data o nagko-convert ng format.

Sa artikulong ito, paraan ng pagputol ng string sa C Gengo tungkol dito, paraan ng paggamit ng mga standard library function, paggawa ng sariling function, paghawak sa mga multibyte character (Nihongo), at paraan ng paghahati ng string ay detalyadong ipapaliwanag. Ipapakita rin ang mga halimbawa ng aplikasyon at paghawak ng error, kaya pakibasa hanggang sa dulo.

Mga matututunan sa artikulong ito

Sa pagbabasa ng artikulong ito, maaari mong matutunan ang mga sumusunod na kasanayan.

• Mga pangunahing konsepto ng mga string sa C at ang terminating character ang papel
• strncpystrchrpaghihiwalay ng bahagi ng string gamit ang mga function ng karaniwang library
• pawang function
• Isinasaalang-alang ang mga multibyte na karakter (Hapon)
• strtok pamamaraan ng paghahati ng string
• Paraan upang makuha ang mga karakter bago at pagkatapos ng isang partikular na karakter

Ipapaliwanag namin nang may kasamang mga halimbawa ng code upang maging madaling maintindihan kahit ng mga baguhan.

Bakit mahalaga ang pagputol ng string sa C Gengo?

Sa C Gengo, ang mga string ay tinatrato bilang “array (array ng char type)” kaya hindi tulad ng ibang high-level na wika (tulad ng Python o JavaScript) na madaling makuha ang bahagi ng string. Dahil dito, mahalagang pumili ng tamang paraan sa mga sitwasyong tulad ng mga sumusunod.

1. Pagproseso ng input data

Halimbawa, kapag sinusuri ang log data o mga CSV file, kailangan mong kunin ang tiyak na mga item.

2. Paghahanap ng tiyak na keyword

Ang paghahanap ng tiyak na keyword sa loob ng isang string at pagkuha ng impormasyon bago at pagkatapos nito ay mahalaga para sa mga function ng paghahanap at pagkuha ng data.

3. Pagpapabuti ng kaligtasan ng programa

Sa pamamagitan ng tamang paggamit ng mga function tulad ng strncpy, maaari mong maiwasan ang buffer overflow (pagsusulat ng data na lumampas sa laki ng buffer). Ito ay mahalaga upang maiwasan ang mga panganib sa seguridad.

Estruktura ng artikulo

Sa artikulong ito, susundan natin ang sumusunod na daloy.

1. Ano ang string sa C language? Mga pangunahing konsepto at kahalagahan ng terminating character
2. Paano mag-extract ng substring sa C language【Bersyon ng Standard Library】
3. Paano mag-extract ng substring sa C language【Sa sariling function】
4. Paraan ng pagkuha ng string ayon sa character code
5. Paano hatiin ang string sa C language
6. Halimbawa ng aplikasyon: Paano kunin ang mga karakter bago at pagkatapos ng isang partikular na karakter
7. buod
8. FAQ

Ngayon, tingnan natin nang detalyado ang “Ano ang string sa C Gengo? Pangunahing konsepto at kahalagahan ng terminator character”.

2. Ano ang mga string sa C? Pangunahing konsepto at kahalagahan ng terminator character

2.1 Pangunahing konsepto ng mga string sa C

Ang string ay “array ng char”

Sa C, itinuturing ang string bilang array ng mga character (array ng uri na char). Halimbawa, ang sumusunod na code ay isang pangunahing halimbawa ng pagdeklara at pagpapakita ng 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;
}

Sa code na ito, ang string na "Hello, World!" ay naka-imbak bilang isang array ng uri na char, at inilalabas gamit ang printf("%s\n", str);.

Estruktura ng string

Ang string na "Hello" ay naka-imbak sa memorya tulad ng sumusunod.

Sa C, ang isang espesyal na character na nagmamarka ng katapusan ng string (null character '\0') ay awtomatikong idinadagdag sa dulo, kaya ang haba ng string ay “aktwal na bilang ng mga character + 1”.

2.2 Kahalagahan ng terminator character (null character '

Ano ang null character?

')

Mga problema kapag walang null character

Ang null character ( '\0') ay isang espesyal na character na nagmamarka ng katapusan ng string. Upang tamaang gamitin ang mga string sa C, kailangan maunawaan ang pag-iral ng null character na ito.

#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;
}

Sa code sa itaas, kung wala ang '\0', hindi makikilala ang katapusan ng "Hello", at maaaring magdulot ito ng di-inaasahang pag-uugali.

2.3 Tamang paraan ng pagdeklara ng string

Kung tulad ng nasa ibaba, nakalimutang ilagay ang terminator character, maaaring magdulot ito ng abnormal na pag-uugali ng memorya.

#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;
}

Sanhi ng error

• printf("%s\n", str);karakter na null '\0'
• Kung wala ang , maaaring maipakita ang ibang data sa memorya.

Paraan ① Gamitin ang string literal

Paraan ② I-deklara ang array nang tahasan

Ang pinaka-karaniwang paraan ng pagdeklara ng string ay ang paggamit ng string literal.

char str[] = "Hello";

Sa pamamaraang ito, awtomatikong idinadagdag ng C compiler ang null character ‘\0’, kaya hindi na kailangan ng espesyal na pagproseso.

2.4 Paano suriin ang sukat ng string

Kung mano-manong isasama ang '\0' sa pagdeklara, isusulat ito tulad ng sumusunod.

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

• Tukuyin ang laki ng bilang ng mga karakter ng laki, at mahalaga na ilagay ang sa dulo.
• Kung nakalimutan mong ilagay ang sa , mangyayari ang hindi inaasahang pag-uugali.

Pag-andar ng strlen

Upang makuha ang haba (bilang ng mga character) ng string, gamitin ang function na 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 Buod

• strlennull character '\0'
• sizeof(str)

3. Paraan ng pagkuha ng bahagi ng string sa C language [Standard Library Edition]

1. Ang mga string sa C ay ipinapakita sa pamamagitan ng array ng char
2. Ang huling karakter (null character '\0') ay nagpapakita ng pagtatapos ng string, kaya dapat itong laging isama
3. Upang makuha ang haba ng isang string strlen gamitin
4. Kung hindi mo itinatakda ang mga string sa tamang paraan, maaaring mangyari ang hindi inaasahang mga error.

3.1 Pagkuha ng bahagi ng string gamit ang strncpy

Upang magkuha ng bahagi ng string sa C language, may paraan na gumagamit ng standard library. Sa seksyong ito, strncpy at strchr at iba pang standard library function upang kunin ang bahagi ng string ay ipapaliwanag.

strncpy Pangunahing syntax

strncpy ay isang function na kumokopya ng bahagi ng string papunta sa ibang buffer。

Basic na halimbawa ng paggamit

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

• dest
• src
• n'\0'

strncpy Mga paalala

#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 Safe na string copy gamit ang strncpy_s

1. Null character '\0' ay kailangang idagdag nang manu-mano strncpyn'\0' ay hindi awtomatikong idinadagdag dest[n] = '\0';
2. Mag-ingat sa buffer overflowdestn

strncpy_s Pangunahing syntax

strncpy_s ay bersyon ng strncpy na pinalakas ang kaligtasan, na makakaiwas sa buffer overflow.

Halimbawa

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

• dest
• destszdest
• src
• n

strncpy_s Mga benepisyo

#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 Pagputol hanggang sa tiyak na karakter gamit ang strchr

• Tukuyin ang laki ng buffer () upang makapag-copy nang ligtas。
• destszn

Gayunpaman, strncpy_s ay idinagdag sa C11 standard, kaya maaaring hindi magamit sa ilang kapaligiran.

strchr Pangunahing syntax

strchr kapag ginamit, mahanap mo ang posisyon ng tiyak na karakter at makuha ang string hanggang doon.

Halimbawa

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

• str
• cchar

Punto

#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 Keyword search at pagputol gamit ang strstr

• strchrunang nahanap na c ang address ay ibinabalik
• pos - strstrncpy

strstr Pangunahing syntax

strstr ay kapaki-pakinabang para maghanap ng bahagi ng string at kunin ang string mula doon.

Halimbawa

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

• haystack
• needle

Punto

#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 Buod

• strstrneedle
• NULLneedlehaystack

4. Paraan ng pagkuha ng bahagi ng string sa C gengo 【Sariling Function】

1. strncpy kapag ginagamit, ligtas mong makokopya ang bahagi ng string ngunit kailangan mong manu-manong idagdag ang null character.
2. strncpy_s ay destsz na tukuyin, at ang kaligtasan ay tumataas.
3. strchr kung gagamitin mo ito, maaari mong makuha ang substring hanggang sa isang partikular na karakter。
4. strstr kung gagamitin mo ito, makukuha mo ang posisyon ng isang partikular na keyword at maaari mong hatiin mula doon.

Sa pamamagitan ng paggamit ng standard library, maaaring mag-implement ng string processing sa C language nang simple at ligtas.

4.1 Mga Benepisyo ng Paggawa ng Sariling Function

Kung gagamitin ang standard library, posible ang pangunahing pagkuha ng bahagi ng string, ngunit sa ilang pagkakataon, kinakailangan ang mas flexible na paraan kaysa . May mga pagkakataon na ay hindi sapat. Kaya, sa seksyong ito, tatalakayin namin ang pagkuha ng bahagi ng string gamit ang sariling function.

4.2 Pangunahing Function para sa Pagkuha ng Bahagi ng String

Kapag gumagamit ng standard library, maaaring kopyahin at hanapin ang bahagi ng string, ngunit may mga problemang tulad ng mga sumusunod.

• strncpy ay hindi awtomatikong nagdaragdag ng null character '\0'
• strchr at strstr ay maaari lamang maghanap nang bahagya
• Mas mahirap ang mas flexible na paghawak ng string

Kaya, epektibo ang paggawa ng sariling function na maaaring i-customize ayon sa partikular na gamit.

Specification ng Function

Una, gagawa tayo ng pangunahing function na magpuputol ng string mula sa tinukoy na posisyon.

Code ng Implementasyon

• parameter
• const char *source
• int start
• int length
• char *dest
• Nilalaman ng pagproseso
• startlengthdest
• '\0'

Punto

#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 Pagkuha ng Dynamic na Bahagi ng String gamit ang malloc

• forlength
• '\0'
• dest[i] = '\0'; siguraduhing ilagay ang null character sa dulo

Specification ng Function

Sa function sa itaas, kinakailangan munang i-allocate ang laki ng dest nang pauna. Ngunit kung maaaring i-allocate nang dynamic ang kinakailangang laki, magiging mas pangkaraniwan ang function.

Code ng Implementasyon

• Kumuha ng kinakailangang memorya gamit ang
• startlength
• Kailangan mong sa tumatawag

Punto

#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 Suporta sa Multi-byte na Character (Nihongo)

• malloc動的にメモリを確保
• Matapos gamitin, kailangan mong iliber ang memorya gamit ang kailangan mong iliber ang memorya。

Implementasyon na Isinasaalang-alang ang Multi-byte na Character

Kapag humahawak ng Nihongo (tulad ng UTF-8 na multi-byte na character), hindi garantisado na ang isang character ay 1 byte, kaya ang simpleng substring function ay hindi gagana nang tama.

Code ng Implementasyon (Suporta sa UTF-8)

• mbstowcswchar_t
• wcsncpy
• wcstombs

Punto

#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 Buod

• setlocale(LC_ALL, "");
• mbstowcs
• wcsncpywcstombs

5. Paraan ng pagputol ng string ayon sa bawat kodigo ng karakter

1. substring kung gagawa mo ito nang sarili mo, maaari mong makuha nang flexible ang mga substring。
2. Kung ginagamit ang dynamic memory allocation (malloc), maaari kang kumuha ng variable-size na substring.
3. Kapag humahawak ng multibyte na mga karakter (Japanese), mbstowcs / wcstombs gamit.

Kung mahirap magamit ang strncpy o strchr ng standard library, sa pamamagitan ng paggawa ng sariling function, maaaring gawing mas makapangyarihan ang pagproseso ng string sa C gengo.

5.1 ASCII（1-byte na karakter）kapag

Sa C na wika, kung hindi mag-iingat sa pagkakaiba ng kodigo ng karakter, maaaring hindi tama ang pag-andar ng proseso ng pagputol ng stringmay mangyari. Lalo na kapag humahawak ng mga multi-byte na karakter tulad ng wikang Hapon (UTF-8、Shift_JIS、EUC-JP atbp.) , dahil hindi 1 karakter＝1バイト, ang simpleng strncpy や substring na mga function ay hindi kayang magproseso nang tama.

Sa seksyong ito, paraan ng pagputol ng string ayon sa bawat kodigo ng karakter tungkol dito ay ipapaliwanag nang detalyado.

Pangunahing pagkuha ng bahagi ng string

Halimbawa ng Implementasyon

Ang mga ASCII na karakter ay 1 karakter = 1 byte kaya, maaaring madaling iproseso gamit ang mga function na strncpy at substring .

5.2 UTF-8（multi-byte na karakter）kapag

#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;
}

Punto

• Kung mga karakter na ASCII (tanging alphanumeric) lamang, strncpy ay sapat na upang tugunan
• '\0'Palaging idagdag ang null character

Katangian ng UTF-8

Tamang paraan ng pagproseso

Sa UTF-8, ang bilang ng byte ng isang karakter ay 1-4 byte at nagbabago, kaya kung gagamitin nang simple ang strncpy ay maaaring maputol ang karakter sa gitna.

Pagkuha ng bahagi ng string na sumusuporta sa UTF-8

Sa C na wika, upang ligtas na iproseso ang UTF-8, inirerekomenda na gamitin ang mbstowcs upang i-convert ito sa wide string ( wchar_t) at kunin ang bahagi ng string.

5.3 Shift_JIS（multi-byte na karakter）kapag

#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;
}

Punto

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

Katangian ng Shift_JIS

Pagkuha ng bahagi ng string na sumusuporta sa Shift_JIS

Sa Shift_JIS, ang 1 karakter ay maaaring 1 byte o 2 byte kaya ang simpleng strncpy ay magdudulot ng pagkasira ng mga karakter.

Implementasyon sa Shift_JIS

Sa kaso ng Shift_JIS, inirerekomenda rin ang pag-convert sa wide string at pagproseso nito .

5.4 EUC-JP（multi-byte na karakter）kapag

#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;
}

Punto

• Para maayos na maproseso ang Shift_JIS, itakda.
• mbstowcswcstombs

Katangian ng EUC-JP

Pagkuha ng bahagi ng string na sumusuporta sa EUC-JP

Ang EUC-JP, tulad ng Shift_JIS, ay may magkaibang bilang ng byte bawat karakter, kaya kinakailangan ang pag-convert gamit ang wide character .

5.5 Buod

#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;
}

Punto

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

6. Paraan ng paghahati ng string sa C gengo

• Kung tanging ASCII characters lamang strncpy ay OK
• Kung UTF-8, Shift_JIS, EUC-JP ay mbstowcs / wcstombs gamitin
• Depende sa kapaligiran setlocale(LC_ALL, "..."); itakda nang tama

6.1 strtok na gamit sa paghahati ng string

Ang proseso ng paghahati ng string ay、pag-analisa ng CSV data, pagproseso ng mga argumento ng command line, pag-analisa ng log data atbp., kinakailangan sa maraming sitwasyon. Sa C gengo, strtok at strtok_r ay mga pamamaraang gumagamit ng mga standard library function o paggawa ng sariling function.

Sa seksyong ito, ang paraan ng paghahati ng string gamit ang tiyak na delimiter ay detalyadong ipapaliwanag.

Pangunahing syntax

strtok ay isang function na naghahati ng string gamit ang tinakdang delimiter (delimitador).

Halimbawa ng paggamit: paghahati ng string gamit ang kuwit ,

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

• str
• delim
• balik na halaga
• Mga Paalalastrtok'\0'

Kinalabasan ng pagtakbo

#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;
}

strtok Mga paalala

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

6.2 strtok_r na gamit para sa thread-safe na paghahati ng string

1. baguhin ang orihinal na string

• strtokdelimiter character na '\0' ay papalitan,

1. hindi thread-safe

• strtokgumagamit ng mga global na static na variable sa loob nito

Pangunahing syntax

strtok_r ay thread-safe na bersyon ng strtok, at dahil iniimbak ang estado sa saveptr, maaari itong magamit nang ligtas kahit sa multi-threaded na kapaligiran.

Halimbawa ng paggamit: paghahati ng string gamit ang puwang

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

• str
• delim
• saveptr

Mga benepisyo ng 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 Paghahati ng string gamit ang sariling function (paraan na hindi gumagamit ng strtok)

• ligtas sa thread
• Kaya magproseso ng maraming string nang sabay-sabay

Specipikasyon ng sariling function

strtok ay nagbabago ng orihinal na string, kaya posible ring gumawa ng sariling function na naghahati ng string nang hindi binabago ito.

Kodigo ng implementasyon

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

Kinalabasan ng pagtakbo

#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;
}

Punto

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

6.4 Pag-aaplay ng paghahati ng string (pagproseso ng CSV data)

• source
• tokens

Halimbawa ng pag-parse ng CSV data

Maaaring i-parse ang CSV (comma-separated) data gamit ang strtok.

Kinalabasan ng pagtakbo

#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 Buod

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

Konklusyon

7. Halimbawa ng Pag-aaplay: Paraan ng Pagkuha ng Teksto Bago at Pagkatapos ng Isang Tiyak na Karakter

• Kung simpleng paghahati strtok
• Kung gumagamit ng multithreading strtok_r
• Kung ayaw mong baguhin ang orihinal, gumawa ng sariling function
• Maaari ring ilapat sa pagsusuri ng CSV data

Sa susunod na seksyon, detalyadong ipapaliwanag ang “Halimbawa ng aplikasyon: Pagkuha ng mga karakter bago at pagkatapos ng tiyak na karakter“.

7.1 strchr gamit kunin ang string bago ang tiyak na karakter

Sa pagproseso ng mga string, madalas na kailangan ang operasyon na magkuha ng mga bahagi bago at pagkatapos ng tiyak na karakter o keyword . Halimbawa, maaaring isaalang-alang ang mga sumusunod na kaso.

• Kunin lamang ang bahagi ng domain mula sa URL
• I-extract ang pangalan ng file mula sa file path
• Kunin ang string bago at pagkatapos ng mga partikular na tag o simbolo

Sa C language, sa pamamagitan ng paggamit ng strchr at strstr , maaaring maisakatuparan ang ganitong mga proseso. Bukod pa rito, kung kailangan ng mas flexible na pagproseso, epektibo rin ang paggawa ng sariling function.

Pangunahing Sintaks

strchr gamit, maaaring matukoy ang posisyon ng tiyak na karakter (ang unang nakita).

Halimbawa ng Paggamit: Kunin ang Pangalan ng File mula sa File Path

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

• str
• cchar

strchr ay magbabalik ng address kapag natagpuan ang c .

Resulta ng Pagpapatakbo

#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;
}

Mga Punto

Filename: report.txt

7.2 strstr gamit kunin ang string pagkatapos ng tiyak na keyword

• strrchrang partikular na karakter na lumitaw sa huli ( / ) na posisyon ay maaaring makuha
• pos + 1maaaring makuha lamang ang pangalan ng file

Pangunahing Sintaks

strstr gamit, maaaring hanapin ang tiyak na string (keyword) at kunin ang string mula sa posisyon nito pababa.

Halimbawa ng Paggamit: Kunin ang Domain mula sa URL

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

• haystack
• needle

strstr ay magbabalik ng address ng posisyon kapag natagpuan ang needle .

Resulta ng Pagpapatakbo

#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;
}

Mga Punto

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

7.3 strchr gamit hatiin ang mga bahagi bago at pagkatapos ng tiyak na karakter

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

Halimbawa ng Paggamit: Paghiwalayin ang Username at Domain mula sa Email Address

strchr gamit, maaaring hatiin at kunin ang mga string bago at pagkatapos ng tiyak na karakter .

Resulta ng Pagpapatakbo

#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;
}

Mga Punto

Username: user
Domain: example.com

7.4 Pag-aaplay: Pagkuha ng tiyak na atributo sa loob ng HTML tag

• strchr'@'
• strncpy'@' na bahagi bago ito, kopyahin at magdagdag ng null character
• strcpy'@' ang bahagi pagkatapos ng kopyahin

Halimbawa ng Paggamit: kunin ang URL mula sa <a href="URL">

Kung nais kunin ang tiyak na atributo mula sa HTML tag, maaari ring gamitin ang strstr .

Resulta ng Pagpapatakbo

#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;
}

Mga Punto

Extracted URL: https://example.com

7.5 Buod

• strstr"href=\""
• strchr"

Konklusyon

8. Buod

• strchr at strstr ay maaaring gamitin upang madali mong makuha ang mga bahagi bago at pagkatapos ng partikular na karakter o keyword
• Ang pagproseso ng file path, pag-parse ng URL, paghahati ng email address, atbp., ay kapaki-pakinabang sa maraming sitwasyon.
• Maaari ring ilapat sa mga advanced na proseso tulad ng web scraping

8.1 Pagsusuri ng Artikulo

Sa artikulong ito, tinalakay namin nang detalyado ang mga paraan ng pagputol ng string sa C Gengo mula sa mga batayan hanggang sa mga advanced na aplikasyon. Dito, titingnan natin muli ang mga mahahalagang punto ng bawat seksyon at isaayos ang pinakamainam na pamamaraan ayon sa gamit.

8.2 Pinakamainam na Paraan Ayon sa Layunin

1. Pagkuha ng Bahaging String

2. Paghiwa-hiwalay ng String

3. Pagkuha ng Mga Bahagi Bago at Pagkatapos ng Tiyak na Karakter

8.3 Mga Tala sa Pagproseso ng String sa C Gengo

1. Sundin ang Malakas na Pamamahala ng Null Terminator '

Halimbawa ng Ligtas na Pagkopya ng String

'

2. Mag-ingat sa Buffer Overflow

Sa pagproseso ng string sa C Gengo, ang tamang pamamahala ng terminator character ‘\0’ ay pinakamahalaga. Lalo na kapag gumagamit ng strncpy o strchr, mag-ingat na magdagdag ng null character nang manu-mano .

3. Gumamit ng mbstowcs sa Pagproseso ng Multi-Byte na Karakter

#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. Pamamahala ng Laki ng Buffer

Sa pag-manipula ng string sa C Gengo, kailangan itong ipatupad nang maingat upang hindi ma-access ang labas ng saklaw ng array. Lalo na kapag gumagamit ng strncpy, mahalaga na kontrolin ang bilang ng mga byte na kinokopya .

Halimbawa ng Ligtas na Pagkopya ng String

8.4 Para sa Karagdagang Pag-aaral

Kapag humahawak ng mga multi-byte na karakter tulad ng UTF-8 o Shift_JIS, hindi tama ang simpleng paggamit ng strncpy o strlen.

Kaya naman, kapag humahawak ng multi-byte na karakter, inirerekomenda na i-convert muna ito sa wide string gamit ang mbstowcs at pagprosesohin nang angkop.

Mga Paksa para sa Mas Malalim na Pag-aaral

Sa pagproseso ng string, mahalaga na kalkulahin nang maaga ang kailangang sukat ng memorya at iwasan ang overflow ng buffer. Lalo na kapag gumagamit ng malloc para mag-allocate ng dynamic memory, siguraduhing alam ang eksaktong sukat nito.

8.5 Buod

Ang pagproseso ng string sa C Gengo ay isang mahalagang kasanayan na nagpapabuti sa kaligtasan at nababasa ng programa 。 Batay sa nilalaman ng artikulong ito, kung pag-aaralan mo pa ang mga sumusunod na paksa, mas mapapalawak mo ang kakayahan sa advanced na pagproseso ng string.

Mga Paksa para sa Mas Malalim na Pag-aaral

1. regular na ekspresyon (regex)
2. Mga operasyon sa file (pagpoproseso ng string gamit ang fgets, fscanf)
3. Pamamahala ng memorya (pagproseso ng dynamic na string gamit ang malloc, realloc)
4. Pagsusuri ng datos（Paraan ng pag-aanalisa ng JSON, XML）

8.5 Buod

1. Ang mga string sa C ay char dahil pinamamahalaan sa pamamagitan ng array, ang terminator character '\0' ang paghawak nito ay mahalaga
2. Para sa pagkuha ng bahagi ng string, strncpy, substring(), malloc gamitin
3. Para sa paghahati ng mga string strtok / strtok_r / paggamit ng sariling function
4. Kung nais mong kunin ang mga karakter bago at pagkatapos ng isang partikular na karakter, gamitin ang strchr, strstr
5. Kung gagamitin ang multi-byte na mga karakter (Jepang), mbstowcs gamitin
6. Mag-ingat sa ligtas na pagproseso ng string, at bigyang-pansin ang buffer overflow.

Kung gagamitin ang mga nilalaman ng artikulong ito, magiging posible ang praktikal na pagproseso ng string sa C gengo na 。 Pagkatapos maunawaan ang mga basic na function, hamunin ang sariling gawang function at applied processing, at maging mas efficient sa pagsusulat ng code!