Baguhan: Gabay sa Char Array ng C | Batayan hanggang Advanced

1. Panimula

Ang wikang C ay isang wika na patuloy na malawakang ginagamit sa mga larangan ng pagbuo ng sistema at embedded development. Sa loob nito, ang “char array” ay isa sa pinaka-pangunahing at mahalagang elemento ng syntax para sa paghawak ng mga string.

Sa C Gengo, walang built-in na uri ng string. Sa halip, ginagamit ang array ng mga karakter (char array) upang ipahayag ang string. Dahil hindi ito lubos na intuitive para sa mga baguhan, madalas na nagiging malaking hadlang ang pag-unawa sa char array sa pag-aaral ng C Gengo.

Gayundin, kung hindi nauunawaan ang tamang paggamit ng char array at char pointer（char*） at ang pag-iral ng null character（\0）, maaaring magdulot ito ng hindi inaasahang mga bug.

Sa artikulong ito, tututukan natin ang temang “C language char array”, mula sa mga pangunahing gamit hanggang sa mga advanced na teknik, at pati na rin ang mga paraan upang maiwasan ang karaniwang mga error, na ipapaliwanag nang malinaw.

Para sa mga nais magsimulang mag-aral nang seryoso ng wikang C, o gustong mag-review tungkol sa char array, pakitingnan hanggang sa huli. Sa susunod na kabanata, ipapaliwanag muna natin ang definisyon ng char array at ang pangunahing mekanismo nito.

2. Ano ang char array?

Sa wikang C, ang “char array” ay, isang array na nag-iimbak ng maraming karakter (uri ng char) nang sabay-sabay. Ito ay pangunahing estruktura sa paghawak ng mga string.

Ano ang uri ng char?

Sa wikang C, char ay isang data type para magrepresenta ng isang karakter. Halimbawa, maaaring magdeklara ng variable na naglalaman ng isang karakter tulad nito.

char c = 'A';

Sa ganitong paraan, 'A' na nakapaloob sa single quote na isang karakter ay char bilang uri ay itinakda.

Pangunahing syntax ng char array

Upang mag-imbak ng maraming karakter, char na array ang gagamitin. Ideklara ito tulad ng sumusunod:

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

Ang array na ito ay, "Hello" isang string na may 5 na karakter na may karagdagang null character(\0) ay naglalaan ng memorya para sa 6 na karakter.

Kahalagahan ng null character('

Sukat ng array at mga dapat tandaan

')

Sa C, ginagamit ang null character null character '\0' upang ipahiwatig ang katapusan ng string. Kung wala ang simbolong ito, ang mga function na nagpoproseso ng string ay hindi gagana nang tama at maaaring magdulot ng hindi inaasahang pag-uugali.

char str[] = "Hello"; // awtomatikong idinadagdag ang '\0' sa dulo

Gaya ng nasa itaas, string literal na nakapaloob sa double quotes kapag ginamit, awtomatikong idaragdag ng compiler ang '\0' sa dulo.

3. deklarasyon at inisyal na pag-assign ng char array

Kapag gumagamit ng char array, kailangan na bilang ng mga karakter + 1(para sa null character) ay dapat maglaan ng sukat na ito. Kung mag-assign ng string sa isang array na kulang ang sukat, buffer overflow ay maaaring magdulot nito, at maaaring mag-crash ang programa.

Statikong deklarasyon at inisyal na pag-assign

Upang magamit ang char array, kailangan muna ang tamang deklarasyon at inisyal na pag-assign. Dito, tatalakayin mula sa pangunahing paraan ng deklarasyon ng char array sa wikang C, kung paano mag-inisyal, at pati na rin ang paggamit ng dynamic memory.

Inisyal na pag-assign gamit ang string literal

Bilang pinaka-pangunahing paraan, may paraan na magdeklara ng laki ng array nang malinaw at i-inisyal ito isang karakter bawat isa.

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

Sa ganitong paraan, ang str ay maaaring ituring bilang string na "Hello" . Ang mahalaga ay laging isama ang '\0' sa dulo.

Pagtukoy ng laki at pag-assign ng literal

Sa wikang C, posible rin ang simpleng inisyal na pag-assign gamit ang string literal tulad ng sumusunod.

char str[] = "Hello";

Sa kasong ito, ang laki ng array ay awtomatikong magiging 6 na karakter, na binubuo ng "Hello" + '\0' . Kung nais baguhin ang nilalaman ng string, sa pamamagitan ng pagdeklara nito bilang char array, maaaring baguhin nang ligtas.

Paggamit ng dynamic memory allocation (malloc)

Maaari ring mag-inisyal gamit ang string literal habang tinutukoy ang laki ng array, ngunit mag-ingat sa kakulangan ng laki.

char str[5] = "Hello"; // ❌ Dahilan ng error (kakulangan ng laki)

Tulad ng nasa itaas, ang "Hello" ay nangangailangan ng kabuuang 6 na karakter: 5 na letra + 1 na karakter (‘\0’). Kaya, kailangan kahit man lang char str[6].

4. Pag-manipula ng String

Kung nais mas flexible na pamahalaan ang mga string, may paraan na gumamit ng malloc upang dynamic na mag-allocate ng char array.

#include
#include 

char* str = malloc(6 * sizeof(char));
strcpy(str, "Hello");

Sa pamamaraang ito, dinadagdagan nang dynamic ang memorya at ginagamit ang pointer upang pamahalaan ang string. Pagkatapos gamitin, huwag kalimutang gamitin ang free(str); upang i-deallocate ang memorya.

Pagkopya ng String: strcpy

Sa Wikang C,char array ang ginagamit sa pagmamanipula ng string, at karaniwang ginagamit ang mga function mula sa standard library. Dito, ipapaliwanag natin ang mga basic na function para sa pagmamanipula ng string at kung paano gamitin ang mga ito, kasama ang mga konkretong halimbawa.

Pagdugtong ng String: strcat

strcpy ay isang function na nagko-copy ng isang string sa ibang char array.

#include

char src[] = "Hello";
char dest[10];
strcpy(dest, src);

Paalala: Kung hindi sapat ang laki ng dest, maaaring maging sanhi ito ng buffer overflow. Siguraduhing ang laki ay sapat para sa haba ng string na kopyahin plus 1 (para sa null character).

Pagkuha ng Haba ng String: strlen

strcat ay nagdugtong ng dalawang string. Idinadagdag nito ang nilalaman ng pangalawang argumento sa dulo ng unang argumento.

#include

char str1[20] = "Hello";
char str2[] = " World";
strcat(str1, str2);

Bilang resulta nito, ang str1 ay magiging "Hello World". Gayundin, dapat sapat ang espasyo sa array ng unang argumento para sa buong laki pagkatapos ng pagdugtong.

Paghahambing ng String: strcmp

strlen function ay nagbabalik ng haba ng string (bilang ng mga character maliban sa null character).

#include

char str[] = "Hello";
int len = strlen(str); // len = 5

Hindi kinakabilang ang null character, kaya kailangang mag-ingat ang mga baguhan sa Wikang C.

Paghahanap sa String: strchr at strstr

Upang ihambing kung magkatulad ang dalawang string, gumamit ng strcmp.

#include

char str1[] = "Hello";
char str2[] = "World";

if (strcmp(str1, str2) == 0) {
    // Magkatulad
} else {
    // Magkaiba
}

Ang function na ito ay nagbabalik ng 0 kung magkatulad, at ang pagkakaiba ng character code kung magkaiba.

5. Pagkakaiba ng char array at pointer

Upang maghanap ng partikular na character o substring, maaaring gumamit ng mga function tulad ng sumusunod.

#include

char str[] = "Hello World";

// Paghahanap ng character
char *ptr1 = strchr(str, 'o'); // Pointer sa unang 'o'

// Paghahanap ng substring
char *ptr2 = strstr(str, "World"); // Pointer sa simula ng "World"

Kung hindi natagpuan, parehong nagbabalik ng NULL ang mga function na ito.

Pagkakaiba ng deklarasyon

Sa C language, kapag humahawak ng mga string, char array at char pointer（char*） ay mukhang magkatulad, ngunit sa katunayan ay may magkaibang katangian . Sa pamamagitan ng tamang pag-unawa sa pagkakaibang ito, maiiwasan ang maling paggamit ng memorya at mga hindi inaasahang bug.

Pagkakaiba sa kakayahang baguhin

Tingnan muna natin ang pagkakaiba sa paraan ng deklarasyon.

char str1[] = "Hello";  // char array
char *str2 = "Hello";   // char pointer

str1 ay isang array na may aktwal na imbakan at naglalaan ng 6 na byte sa memorya (“Hello” + ‘\\0’). Sa kabilang banda, str2 ay isang pointer patungo sa memorya kung saan nakalagay ang string literal.

Pagkakaiba sa estruktura ng memorya

Ang char array na si str1 ay maaaring malayang baguhin ang mga karakter sa loob ng array.

str1[0] = 'h'; // OK

Gayunpaman, kapag tulad ng char* str2 = "Hello"; ay nag-aaccess sa string literal gamit ang pointer, ang pagbabago ng nilalaman nito ay hindi tinukoy na pag-uugali.

str2[0] = 'h'; // ❌ Hindi tinukoy na pag-uugali（posibleng runtime error）

Pagkakaiba sa pagkuha ng sukat

• Ang array ng char
• char pointerconstant na lugar (read-only)heap na lugar (malloc atbp.)kailangan maging maingat sa paghawak ng memorya

Buod: Mga Punto sa Paggamit

Sa kaso ng array, ang sizeof(str1) ay nagbabalik ng kabuuang bilang ng byte ng array.

char str1[] = "Hello";
printf("%lu", sizeof(str1)); // → 6（kasama ang '\\0'）

Sa kabilang banda, para sa pointer, ang sizeof(str2) ay nagbabalik ng sukat ng mismong pointer (karaniwan 4-8 byte), kaya hindi ito magagamit para kunin ang sukat ng array.

char *str2 = "Hello";
printf("%lu", sizeof(str2)); // → 8（64-bit na kapaligiran）

6. Paano Ipass ang Char Array sa Function

Basic na Halimbawa: Pagpasa ng char array bilang argumento

Sa C language, kapag nagpapasa ng array sa isang function, hindi ito “value passing” kundi “pointer passing” ang ginagawa. Ganito rin ang char array , at kapag ipinapasa sa function, ang unang address (pointer) ay ipinapasa.

Mahalagang maunawaan ang mekanismong ito sa mga sitwasyon kung saan nag-ooperate o nagbabago ng mga string sa pagitan ng mga function.

Function na Nagbabago ng Nilalaman

#include

void printString(char str[]) {
    printf("String: %s\n", str);
}

int main() {
    char greeting[] = "Hello";
    printString(greeting);
    return 0;
}

Sa halimbawang ito, ang function na printString ay tumatanggap ng argument na uri ng char[], ngunit sa katunayan ay tinatanggap ito bilang char* . Ibig sabihin, ang char str[] ay katumbas ng char *str .

Pangangasiwa ng Laki ng Array

Kahit kapag binabago ang nilalaman ng array sa loob ng function, maaari mong direktang manipulahin ang data sa pamamagitan ng ipinasa na address.

#include

void toUpperCase(char str[]) {
    for (int i = 0; str[i] != '\0'; i++) {
        if ('a' <= str[i] && str[i] <= 'z') {
            str[i] = str[i] - ('a' - 'A');
        }
    }
}

int main() {
    char text[] = "hello world";
    toUpperCase(text);
    printf("%s\n", text); // Output: HELLO world
    return 0;
}

Sa ganitong paraan, kahit nais mong baguhin ang laman ng array, dahil ito ay tinatrato bilang pointer, ang operasyon sa loob ng function ay makikita sa tumawag na bahagi .

Read-Only Argument Gamit ang const

Sa C language, kapag nagpapasa ng array sa function, hindi kasama ang impormasyon ng laki. Kaya, para sa ligtas na operasyon, pinakamainam na ipasa rin ang laki bilang argumento.

void printChars(char str[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%c ", str[i]);
    }
    printf("\n");
}

Gayundin, karaniwan ang paggamit ng function na strlen upang dynamic na makuha ang haba ng string. Ngunit mag-ingat na huwag gamitin ito sa mga array na walang null termination.

7. Halimbawa ng Praktis: Pagpapakita ng String nang Baliktad

Kung hindi babaguhin ang string sa loob ng function, hindi ito babaguhin, mas mainam na gamitin ang const char* upang ipahiwatig na ito ay read-only.

void printConstString(const char *str) {
    printf("%s\n", str);
}

Ito ay nakakatulong upang maiwasan ang hindi sinasadyang pagbabago at malinaw na maiparating ang espesipikasyon ng function.

Layunin

Dito, gagamitin natin ang kaalaman tungkol sa char配列 , upang aktwal na gumawa ng programang magpapakita ng string nang baliktad.

Halimbawang Kodigo

Ipinapakita ang string na inilagay ng gumagamit, isa-isa mula sa hulihan patungo sa simula. Ito ay napaka-epektibo bilang pag-manipula ng array, pagkuha ng haba ng string, at pagsasanay sa loop.

Paliwanag

#include
#include 

void printReversed(char str[]) {
    int len = strlen(str);
    for (int i = len - 1; i >= 0; i--) {
        putchar(str[i]);
    }
    putchar('\n');
}

int main() {
    char text[100];

    printf("Ilagay ang string:");
    fgets(text, sizeof(text), stdin);

    // Alisin ang newline character (para sa paggamit ng fgets)
    size_t len = strlen(text);
    if (len > 0 && text[len - 1] == '\n') {
        text[len - 1] = '\0';
    }

    printf("Kapag ipinakita nang baliktad:");
    printReversed(text);

    return 0;
}

Halimbawa ng Pagpapatakbo

• fgets
• Huwag kalimutang isagawa ang proseso ng pagtanggal ng (karaniwang character ng bagong linya) na idinadagdag sa dulo ng input。
• strlen()

Mga Tip para sa Pag-aaplay

Ilagay ang string: OpenAI
Kapag ipinakita nang baliktad: IAnepO

8. Karaniwang mga Error at ang Kanilang Mga Solusyon

Ang prosesong ito ay nag-uugnay sa pagkilala ng palindrome at pag-unawa sa istruktura ng stack, na kapaki-pakinabang sa pag-aaral ng mga algoritmo. Maaari ring baguhin gamit ang pointer arithmetic, kaya ito ay nagiging mas advanced na materyal para sa pagsasanay.

1. Nakalimutang Maglagay ng Null Terminator (

2. Kakulangan sa Laki ng Buffer

)

Sa paghawak ng mga char array sa wikang C, may ilang mga patibong na madalas mahulog ng mga baguhan hanggang sa mga dalubhasa. Dito, tatalakayin natin nang detalyado ang mga karaniwang error at ang mga hakbang para maiwasan at lutasin ang mga ito.

3. Pagbabago ng String Literal

Isa sa pinakakaraniwang pagkakamali ay ang hindi paglagay ng null character (\0) sa dulo ng string.

char str[5] = {'H', 'e', 'l', 'l', 'o'}; // ❌ Walang '\0' sa dulo
printf("%s\n", str); // Hindi natutukoy na pag-uugali

Solusyon:

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

O, sa pamamagitan ng paggamit ng string literal, awtomatikong idaragdag ang null character.

4. Nakalimutang Iproseso ang Newline Character ng fgets

strcpy at strcat tulad ng mga function, kung kulang ang laki ng destination array, magdudulot ito ng memory corruption (buffer overflow).

char str1[5];
strcpy(str1, "Hello"); // ❌ Kopya ng 6 na character sa array na sukat 5

Solusyon:

• Sa destinasyon ng kopya, (halimbawa: ‘bilang ng mga karakter + 1’)
• Isaalang-alang din ang paggamit ng mas ligtas na

char str1[6];
strncpy(str1, "Hello", sizeof(str1) - 1);
str1[5] = '\0'; // Para sa siguro, explicit na null character sa dulo

5. Paghalo ng Pointer at Array

char *str = "Hello"; Ang pointer na dineklara tulad ng ito ay maaaring tumukoy sa isang read‑only na memory. Ang pagsulat dito ay magdudulot ng runtime error.

char *str = "Hello";
str[0] = 'h'; // ❌ Sa runtime, Segmentation fault

Solusyon:

char str[] = "Hello"; // ✅ Idineklara bilang array na maaaring baguhin
str[0] = 'h';

9. Buod

fgets kapag ginamit para kunin ang string, dapat tandaan na may newline character (\n) na naiwan sa dulo.

fgets(str, sizeof(str), stdin);
// Sa str, pumasok ang nilalaman tulad ng "Hello\n\0"

Solusyon:

size_t len = strlen(str);
if (len > 0 && str[len - 1] == '\n') {
    str[len - 1] = '\0';
}

Ano ang natutunan sa artikulong ito

Dahil magkatulad ang hitsura, maaaring paghaluin ang char* at char[] na magreresulta sa undefined behavior. Kailangan isaalang-alang ang pagkakaiba sa pagkuha ng sukat (sizeof) at kung maaaring baguhin ang nilalaman.Pagkakaiba sa pagkuha ng sukat (sizeof) at pagkakaiba sa kung maaari bang baguhin ay kailangang isaalang-alang.

Mga payo para sa susunod na pag-aaral

Sa artikulong ito, tinalakay namin ang “char array sa C language” mula sa mga batayan hanggang sa mga aplikasyon nang sunud-sunod. Sa huli, magbabalik-tanaw kami sa nilalaman ng artikulo at magbibigay ng mga patnubay para sa susunod na pag-aaral.

Ano ang natutunan sa artikulong ito

• Ang papel at paraan ng deklarasyon ng char array
• Kahalagahan ng string literal at null character ( \0 )
• Paggamit ng mga function ng standard library para sa pagproseso ng stringstrcpystrcatstrlenstrcmp
• Pagkakaiba ng char array at char pointer
• Paano magpasa ng array sa function at pag-iingat sa kaligtasan
• Pagpapalakas ng pag-unawa sa pamamagitan ng mga halimbawa ng praktis at karaniwang mga error

Mga payo para sa susunod na pag-aaral

Ang pag-unawa sa paggamit ng char array ay unang hakbang sa pag-unawa sa batayan ng memory operation sa C language. Ang kaalaman na natutunan dito ay maaaring magamit sa mga susunod na hakbang tulad ng sumusunod.

• Arithmetic ng pointer
• Pamamahala ng Dinamikong Memoryamallocfree
• Pagsasama ng mga istruktura

Sa pamamagitan ng pagbabasa ng code na isinulat ng iba, maaari mong masipsip ang mga pananaw at estilo na wala sa iyo. Ang pagbuo ng gawi ng pagbabasa ng mga totoong proyekto at OSS (Open Source Software) ay napaka-epektibo.

Ang C language ay may mataas na antas ng kalayaan, kaya kung hindi ito tama ang paggamit ay maaaring mapanganib, ngunit kung maingat mong itayo ang mga batayan, ito ay magiging napakalakas na sandata. Ang pag-unawa sa char array ay unang hakbang. Mangyaring gamitin ang artikulong ito bilang sanggunian at patuloy na pagbutihin ang iyong kakayahan.