Concepts of String: character array, pointer to character array, use of string.h and its functions (strcmp, strcat, strcpy, strlen, strrev)

📖 Theory

"Masala Dosa" ક્યાં વસે છે?

Till એ વસ્તુઓનાં નામ સંઘરવાં પડે છે: "Chai", "Masala Dosa", "Chhaas".

આશ્ચર્ય આ છે: મૂળ C++ ને C માંથી કોઈ જડેલો string નો પ્રકાર મળ્યો જ નથી. 12 માટે int છે, 12.50 માટે double છે, અને લખાણ માટે... એવું કશું નહીં.

તો 1972 થી દરેક C ના program એ લખાણ કેવી રીતે સંભાળ્યું? એક યુક્તિથી: હરોળમાં ઊભેલી chars ની ફોજ, વત્તા હરોળ ક્યાં પૂરી થાય એ ચીંધતો એક અદૃશ્ય રખેવાળ.

📖 Theory

ગાર્ડના ડબ્બાવાળી ટ્રેન

String ને ટ્રેન તરીકે વિચારો: દરેક ડબ્બો એક અક્ષર લઈ જાય છે, C, h, a, i. છેડે એક ગાર્ડનો ડબ્બો ચાલે છે જે મુસાફરો ક્યારેય જોતા નથી: null અક્ષર \0.

String નું દરેક function એ જ રીતે કામ કરે છે: engine થી શરૂ કરો અને ગાર્ડ સુધી ડબ્બે ડબ્બે ચાલો. એ રીતે એમને ખબર પડે છે કે string ક્યાં અટકે છે. ગાર્ડ ખોવાય તો function અસ્તવ્યસ્ત memory માં ચાલવા માંડે છે.

📖 Theory

Character array, ઔપચારિક રીતે

C શૈલીની string એ char નો array છે જેની સામગ્રી null terminator `\0` થી પૂરી થાય છે:

char item[6] = "Chai";

Memory: C h a i \0 (5 ખાનાં વપરાયાં, 1 વધારાનું). "Chai" માં 4 દેખાતા અક્ષર છે પણ એને 5 bytes જોઈએ છે.

બે નિયમ: array લખાણ વત્તા \0 માટે પૂરતો મોટો હોવો જોઈએ, અને declaration પછી તમે = થી સોંપી શકતા નથી (item = "Dosa" ગેરકાયદે છે, arrays સોંપી શકાતા નથી: નકલ કરવી એ function નું કામ છે).

📖 Theory

Pointer ટ્રેન પર ચાલે છે

char નું pointer પહેલા ડબ્બાનું સરનામું રાખે છે:

char *p = item;

હવે *p એ 'C' છે, અને p++ પછીના અક્ષર પર ખસે છે. આ loop string ને એ જ રીતે છાપે છે જે રીતે library પોતે છાપત:

while (*p != '\0') { cout << *p; p++; }

નીચેનું string.h નું દરેક function ચૂપચાપ આ જ loop છે, જુદો ગણવેશ પહેરીને. આ ચાલવાનું એક વાર સમજો અને પાંચેય functions સ્પષ્ટ થઈ જાય છે.

⌨️ Practical

<cstring> ના પાંચ કામગરા

#include <iostream>
#include <cstring>
using namespace std;

int main() {
    char a[20] = "Masala";
    char b[] = "Dosa";

    cout << strlen(b) << endl;   // 4, the guard \0 is not counted

    strcat(a, b);                // a becomes "MasalaDosa"
    cout << a << endl;

    char copy[20];
    strcpy(copy, a);             // copy now holds "MasalaDosa"

    cout << strcmp("Chai", "Chai") << endl;  // 0 means EQUAL
    cout << strcmp("Chai", "Dosa") << endl;  // negative: C before D
    return 0;
}

📊 At a glance

string.h એક નજરમાં

💭 Think first

જાતે ગણો

char t[10] = "Chai";

Tap કરતાં પહેલાં, બંનેના જવાબ આપો: strlen(t) શું પાછું આપે છે, અને "Chai" ખરેખર array નાં કેટલાં bytes રોકે છે?

🧩 Quiz

Till સભ્યપદ તપાસે છે: if (strcmp(entered, "STAFF123")). Password બરાબર મળે છે. strcmp શું પાછું આપે છે, અને if ચાલે છે?

1. 0 પાછું આપે છે, એટલે if **ચાલતું નથી**
2. 1 (true) પાછું આપે છે, એટલે if ચાલે છે
3. 0 પાછું આપે છે, અને 0 એ true છે એટલે if ચાલે છે
4. એ string ની લંબાઈ, 8, પાછી આપે છે

⚠️ Watch out

અહીં marks ગળે છે

strcmp ના 0 ની ગૂંચવણ: તમારા જવાબમાં લખો કે 0 એટલે સરખાં, ઋણ એટલે પહેલી string કક્કાવારીમાં પહેલાં આવે છે, ધન એટલે પછી.

strcpy નો ઊભરો: char[10] માં 15 અક્ષર નકલ કરવાનું બરાબર compile થાય છે અને ચાલતી વખતે memory બગાડે છે.

strrev પ્રમાણભૂત નથી: એ Turbo C માં છે પણ GCC માં નહીં. GCC ના વાતાવરણમાં તમે તમારા પોતાના loop થી ઊલટાવો છો; પુછાય તો એમ કહો.

📖 Theory

આગળનો પુલ

C++ પછીથી std::string class આપે છે, જે પોતાની memory સંભાળે છે, = અને + ને ચાલવા દે છે, અને આમાંના મોટા ભાગના ફાંદા દૂર કરે છે. તમારી પરીક્ષા હજી પહેલાં char arrays અને string.h ની જ કસોટી કરે છે, કારણ કે એ શીખવે છે કે memory માં લખાણ ખરેખર શું છે. તમે classes સુધી પહોંચો, ત્યારે નોંધજો કે std::string એ ફક્ત આ જ ટ્રેન-અને-ગાર્ડ ના વિચાર આસપાસ કોઈએ લખેલો class છે.

✅ Summary

Key takeaways

• C-string એ null terminator \0 થી પૂરો થતો char નો array છે: "Chai" ને 4 અક્ષર માટે 5 bytes જોઈએ.
• char નું pointer array પર ડબ્બે ડબ્બે ચાલે છે જ્યાં સુધી \0 ન મળે.
• strlen \0 વગર ગણે છે; strcpy નકલ કરે છે; strcat જોડે છે; બંનેને પૂરતું મોટું લક્ષ્ય જોઈએ.
• strcmp સરખાં હોય તો 0 પાછું આપે છે (== 0 થી કસો), કક્કાવારીના ક્રમ માટે ઋણ કે ધન.
• strrev જગ્યા પર જ ઊલટાવે છે પણ પ્રમાણભૂત નથી (ફક્ત Turbo C, GCC નહીં).
• Arrays ને = થી સોંપી શકાતા નથી; લખાણની નકલ કરવી એ strcpy નું કામ છે.
• Memory hook: ગાર્ડના ડબ્બાવાળી ટ્રેન.