C స్ట్రింగ్స్, '\0' నల్ టెర్మినేటర్ & <string.h> లైబ్రరీ
మనం పుస్తకంలో ఒక వాక్యం చదివేటప్పుడు, ఆ వాక్యం ఎక్కడ ముగిసిందో మన కళ్లకు ఎలా తెలుస్తుంది? వాక్యం చివర ఉండే చుక్క లేదా ఫుల్స్టాప్ (.) ద్వారానే కదా! అదే విధంగా ఒక రైలు పట్టాలపై దూసుకుపోతున్నప్పుడు, స్టేషన్ మాస్టర్కు రైలులోని ఆఖరి బోగీ ఇదేనని ఎలా తెలుస్తుంది? చిట్టచివరి బోగీ వెనుక అమర్చిన ఎరుపు రంగు లైట్ లేదా LV (Last Vehicle) బోర్డు ఆధారంగానే కదా!
కంప్యూటర్ సైన్స్లో C లాంగ్వేజ్కు ప్రత్యేకమైన "String" అనే ప్రాథమిక డేటా టైప్ ఏదీ ఉండదు! C లో ఒక స్ట్రింగ్ అంటే కేవలం క్యారెక్టర్ల వరుస అర్రే (Array of Characters) మాత్రమే. మరి ఆ అక్షరాల వరుస ఎక్కడ ముగిసిందో కంప్యూటర్ RAM కి ఎలా తెలుస్తుంది? దానికోసమే C సృష్టికర్త డెన్నిస్ రిచీ ప్రతి స్ట్రింగ్ చివర ఒక అదృశ్య రక్షకుడిని ఉంచారు: అదే నల్ టెర్మినేటర్ '\0' (Null Terminator - ASCII 0)!
ఆ '\0' లేకపోతే, కంప్యూటర్ స్క్రీన్ పై పిచ్చి పిచ్చి గార్బేజ్ అక్షరాలు ప్రింట్ అవుతాయి, ప్రోగ్రామ్ మెమరీ క్రాష్ అవుతుంది. ఈ పద్నాలుగవ అధ్యాయంలో, క్యారెక్టర్ అర్రేల అంతర్గత నిర్మాణం, <string.h> లోని ప్రముఖ ఫంక్షన్లు (strlen, strcpy, strcat, strcmp), సురక్షితమైన fgets() వినియోగం, మరియు హ్యాకర్ల బారిన పడకుండా రక్షించే సెక్యూర్ క్రెడెన్షియల్ ఆథెంటికేషన్ ఇంజిన్ను సమగ్రంగా నిర్మిద్దాం!
టెక్స్ట్ ప్రాసెసింగ్, యూజర్ ఇన్పుట్ హ్యాండ్లింగ్, మరియు సైబర్ సెక్యూరిటీలో స్ట్రింగ్స్ అనేవి అత్యంత కీలకమైన అంశం. ఈ అధ్యాయంలో కవర్ చేయబడే ప్రధానాంశాలు:
- C లో స్ట్రింగ్ ఫిలాసఫీ: Primitive String టైప్ లేకపోవడానికి చారిత్రక కారణాలు మరియు క్యారెక్టర్ అర్రే ఆర్కిటెక్చర్.
- నల్ టెర్మినేటర్ '\0' రహస్యం: ASCII విలువ 0 మరియు స్ట్రింగ్ ముగింపును గుర్తించే సెక్యూరిటీ గార్డ్.
- ది +1 బైట్ రూల్ (The +1 Allocation Rule): 5 అక్షరాల పదానికి 6 బైట్ల మెమరీ ఎందుకు తప్పనిసరి?
- స్ట్రింగ్ ఇనిషియలైజేషన్ పద్ధతులు: డబుల్ కోట్స్ (
"Hello") వర్సెస్ క్యారెక్టర్ లిస్ట్ ({'H','e','l','l','o','\0'}). - స్టాక్ స్ట్రింగ్ vs స్ట్రింగ్ లిటరల్ (Read-Only Memory):
char str[]మరియుchar *strమధ్య డేంజర్ డిఫరెన్స్. - స్ట్రింగ్ ఇన్పుట్ మెథడ్స్ పోస్ట్మార్టం:
scanf("%s")లో స్పేస్ సమస్య, పాతgets()నిషేధం &fgets()సేఫ్టీ. - సమగ్ర తులనాత్మక పట్టిక: <string.h> లోని ప్రాథమిక vs సురక్షిత ఫంక్షన్ల విశ్లేషణ.
- పొడవు గణన: strlen() vs sizeof(): నల్ క్యారెక్టర్ను లెక్కింపులో పరిగణించే తేడాలు.
- కాపీ & కాన్క్యాటనేషన్:
strcpy/strncpyమరియుstrcat/strncatపనితీరు. - స్ట్రింగ్ కంపారిజన్:
==ఆపరేటర్ ఎందుకు పనిచేయదు?strcmp()లెక్సికోగ్రాఫికల్ డిక్షనరీ ఆర్డర్. - సమగ్ర రియల్ వరల్డ్ ప్రాజెక్ట్: సెక్యూర్ యూజర్ అకౌంట్ లాగిన్ & పాస్వర్డ్ కాంప్లెక్సిటీ వాలిడేటర్.
- బిగినర్స్ చేసే టాప్ 5 స్ట్రింగ్ తప్పులు: బఫర్ ఓవర్ఫ్లో, స్ట్రింగ్ కాపీ లోపాలు, మరియు డ్యాంగ్లింగ్ రీడ్-ఓన్లీ రాతలు.
- స్వీయ మూల్యాంకన క్విజ్: 5 లోతైన ప్రాక్టికల్ ప్రశ్నలు & గేట్ ఎగ్జామ్ కాన్సెప్ట్స్.
జావా (Java) లో String ఉంది, పైథాన్ (Python) లో str ఉంది, C++ లో std::string ఉంది. కానీ C లాంగ్వేజ్లో అటువంటి ప్రత్యేకమైన స్ట్రింగ్ క్లాస్ లేదా టైప్ ఏదీ లేదు!
డెన్నిస్ రిచీ డిజైన్ ఫిలాసఫీ (1972):
C భాష ఆపరేటింగ్ సిస్టమ్స్ (Unix) మరియు ఎంబెడెడ్ డివైసెస్ నిర్మించడానికి పుట్టింది. ఆ రోజుల్లో మెమరీ కేవలం కొన్ని కిలోబైట్లు మాత్రమే ఉండేది. స్ట్రింగ్స్ కోసం ప్రత్యేకమైన డైనమిక్ ఆబ్జెక్టులను సృష్టిస్తే మెమరీ ఓవర్హెడ్ పెరుగుతుంది. అందుకే అత్యంత తేలికైన, వేగవంతమైన పరిష్కారంగా క్యారెక్టర్ల 1D అర్రేనే (char array) స్ట్రింగ్గా ఉపయోగించాలని నిర్ణయించారు!
స్ట్రింగ్ అనేది సాధారణ క్యారెక్టర్ అర్రే అయినప్పుడు, ఆ అర్రేలో అసలైన టెక్స్ట్ ఎక్కడ ముగిసిందో కంపైలర్కు ఎలా తెలుస్తుంది? దానికోసమే నల్ క్యారెక్టర్ (Null Character - '\0') ను ఉపయోగిస్తారు. దీని ASCII విలువ సరిగ్గా 0.
'\0' కోసం కేటాయించబడుతుంది!
ఇండెక్స్ : [0] [1] [2] [3] [4] [5]
క్యారెక్టర్: 'I' 'N' 'D' 'I' 'A' '\0'
ASCII విలువ: 73 78 68 73 65 0
C లో స్ట్రింగ్ను డిక్లేర్ చేయడానికి మరియు ప్రారంభించడానికి క్రింది పద్ధతులు ఉన్నాయి:
#include <stdio.h>
int main() {
// పద్ధతి 1: డబుల్ కోట్స్ (సిఫార్సు చేయబడినది - '\0' ఆటోమేటిక్గా చేరుతుంది!)
char greeting[] = "నమస్కారం";
// పద్ధతి 2: నిర్దిష్ట సైజుతో డబుల్ కోట్స్ (మిగిలిన గదులు 0 తో నిండుతాయి)
char city[10] = "హైదరాబాద్";
// పద్ధతి 3: విడివిడి క్యారెక్టర్స్ (⚠️ చివర '\0' కచ్చితంగా మనమే రాయాలి!)
char lang[] = {'C', ' ', 'P', 'r', 'o', 'g', '\0'};
printf("గ్రీటింగ్: %s\n", greeting);
printf("సిటీ : %s\n", city);
printf("లాంగ్వేజ్: %s\n", lang);
return 0;
}
⚠️ ప్రాణాంతక తేడా: char[] vs char* (Stack vs Read-Only Literal):
ఇది స్టాక్ మెమరీపై సృష్టించబడిన సాధారణ క్యారెక్టర్ అర్రే. ఇందులో ఉన్న అక్షరాలను str[0] = 'M'; అని స్వేచ్ఛగా మార్చవచ్చు!
ఇది RAM లోని Read-Only Text Segment లో నిల్వ అవుతుంది. దీనిలోని అక్షరాన్ని మార్చడానికి ప్రయత్నిస్తే ఆపరేటింగ్ సిస్టమ్ Segmentation Fault తో క్రాష్ చేస్తుంది!
యూజర్ నుండి టెక్స్ట్ను చదవడం C లో అత్యంత వివాదాస్పదమైన అంశం. అనుభవం లేని బిగినర్స్ చేసే తప్పుల వలన సాఫ్ట్వేర్ ప్రపంచంలో బిలియన్ల డాలర్ల నష్టం జరిగింది:
1. scanf("%s", str) లోని సమస్య:
scanf అనేది మొదటి స్పేస్ (White Space) రాగానే చదవడం ఆపేస్తుంది! ఉదాహరణకు యూజర్ "మన కంప్యూటర్" అని టైప్ చేస్తే, కేవలం "మన" మాత్రమే చదువుతుంది, మిగిలినది వదిలేస్తుంది.
2. నిషేధించబడిన gets() విపత్తు (The Banned gets Function):
గతంలో పూర్తి లైన్ చదవడానికి gets(str) వాడేవారు. కానీ దీనికి బఫర్ పరిమితి అంటూ ఏదీ ఉండదు! 10 సైజు ఉన్న అర్రేలోకి యూజర్ 100 అక్షరాలు టైప్ చేస్తే, అది మిగిలిన మెమరీని కరప్ట్ చేస్తుంది. దీనివలన 1988 లో ప్రసిద్ధ Morris Worm ఇంటర్నెట్ను స్తంభింపజేసింది! ఆధునిక C11 స్టాండర్డ్ లో gets() ని పూర్తిగా తొలగించారు.
3. ఆధునిక గోల్డెన్ స్టాండర్డ్: fgets()
fgets() బఫర్ సైజును ఖచ్చితంగా గౌరవిస్తుంది మరియు స్పేసెస్తో కూడిన పూర్తి వాక్యాన్ని సురక్షితంగా చదువుతుంది:
#include <stdio.h>
#include <string.h>
int main() {
char fullName[50];
printf("మీ పూర్తి పేరు నమోదు చేయండి: ");
// గరిష్టంగా 50 బైట్లు మాత్రమే చదువుతుంది (బఫర్ ఓవర్ఫ్లో అసాధ్యం!)
fgets(fullName, sizeof(fullName), stdin);
// fgets చివర వచ్చే న్యూలైన్ '\n' ని తొలగించే ఇంజనీరింగ్ ట్రిక్
fullName[strcspn(fullName, "\n")] = '\0';
printf("స్వాగతం, %s! మీ ఖాతా విజయవంతంగా లోడ్ అయింది.\n", fullName);
return 0;
}
C స్టాండర్డ్ లైబ్రరీ <string.h> లోని ముఖ్యమైన ఫంక్షన్లను మరియు వాటి ఆధునిక సురక్షిత ప్రత్యామ్నాయాలను క్రింది పట్టికలో పరిశీలిద్దాం:
| ఫంక్షన్ పేరు | ప్రాథమిక విధి | రిటర్న్ టైప్ | భద్రతా హెచ్చరిక / ప్రో-టిప్ |
|---|---|---|---|
strlen(s) |
స్ట్రింగ్ లోని అక్షరాల సంఖ్యను లెక్కిస్తుంది. | size_t (పూర్ణాంకం) |
ఇది నల్ టెర్మినేటర్ '\0' ను లెక్కింపులో కలపదు! |
strcpy(dest, src) |
ఒక స్ట్రింగ్ను మరొకదానిలోకి కాపీ చేస్తుంది. | char* |
⚠️ dest సైజు చిన్నదైతే బఫర్ ఓవర్ఫ్లో వస్తుంది. strncpy వాడండి. |
strncpy(dest, src, n) |
గరిష్టంగా $n$ అక్షరాలను మాత్రమే సురక్షితంగా కాపీ చేస్తుంది. | char* |
✅ సురక్షితమైనది; సైజు పరిమితిని దాటదు. |
strcat(dest, src) |
రెండు స్ట్రింగ్లను ఒకదాని వెనుక ఒకటి అతికిస్తుంది (Concatenate). | char* |
⚠️ డెస్టినేషన్లో తగినంత ఖాళీ ఉండాలి. strncat మేలు. |
strcmp(s1, s2) |
రెండు స్ట్రింగ్లను డిక్షనరీ ఆర్డర్ ప్రకారం పోల్చుతుంది. | int (<0, ==0, >0) |
రెండు సమానమైతే 0 రిటర్న్ చేస్తుంది! |
strstr(haystack, needle) |
ఒక పెద్ద స్ట్రింగ్ లోపల చిన్న సబ్స్ట్రింగ్ ను వెతుకుతుంది. | char* (పాయింటర్) |
దొరికితే ఆ అడ్రస్ ఇస్తుంది; లేకపోతే NULL ఇస్తుంది. |
strtok(str, delim) |
స్ట్రింగ్ను టోకెన్లుగా (ముక్కలుగా) విడదీస్తుంది (CSV Parser). | char* |
ఒరిజినల్ స్ట్రింగ్ను సవరిస్తుంది (Destructive). |
ఇంటర్వ్యూలలో విద్యార్థులను బోల్తా కొట్టించే అత్యంత ప్రసిద్ధ ట్రిక్ ప్రశ్న: strlen() మరియు sizeof() ల మధ్య తేడా ఏమిటి?
#include <stdio.h>
#include <string.h>
int main() {
char title[20] = "Telugu";
// strlen: కేవలం అసలైన అక్షరాలను మాత్రమే లెక్కిస్తుంది (' ' కి ముందు వరకు)
printf("strlen(title) = %zu (అక్షరాల పొడవు)\n", strlen(title));
// sizeof: ఆ అర్రే కోసం RAM లో కేటాయించిన మొత్తం మెమరీ బైట్లను ఇస్తుంది
printf("sizeof(title) = %zu (మొత్తం మెమరీ సైజు)\n", sizeof(title));
return 0;
}
strlen(title) = 6 ("Telugu" లో 6 అక్షరాలు ఉన్నాయి).sizeof(title) = 20 (మనం char title[20] అని డిక్లేర్ చేశాం కాబట్టి మొత్తం 20 బైట్లు కేటాయించబడింది).
C లో str1 = str2; అని స్ట్రింగ్లను నేరుగా కాపీ చేయలేము. ఎందుకంటే అర్రే పేర్లు స్థిరమైన పాయింటర్లు. దీనికోసం strcpy() లేదా మరింత సురక్షితమైన strncpy() వాడాలి:
#include <stdio.h>
#include <string.h>
int main() {
char source[] = "మన కంపైలర్";
char destination[30];
// 1. కాపీ చేయడం: source నుండి destination కి
strcpy(destination, source);
printf("కాపీ చేయబడిన స్ట్రింగ్: %s\n", destination);
// 2. కాన్క్యాటనేషన్ (అతికించడం): చివర కొత్త పదాన్ని కలపడం
strcat(destination, " 2026");
printf("అతికించిన తర్వాత: %s\n", destination);
return 0;
}
చాలామంది బిగినర్స్ రెండు స్ట్రింగ్లు సమానమా కాదా అని చూడటానికి if (str1 == str2) అని రాస్తుంటారు. ఇది పూర్తిగా తప్పు!
str1 == str2 అని రాస్తే, అది అక్షరాలను పోల్చదు; ఆ రెండు అర్రేలు RAM లో ఒకే చిరునామాలో ఉన్నాయా లేదా అని పోల్చుతుంది! ఎల్లప్పుడూ రెండు వేర్వేరు అర్రేల అడ్రస్లు భిన్నంగా ఉంటాయి కాబట్టి ఫలితం ఫాల్స్ వస్తుంది!
అక్షరాలను పోల్చడానికి కచ్చితంగా strcmp(s1, s2) ఉపయోగించాలి. ఇది అక్షరాల ASCII విలువల ఆధారంగా డిక్షనరీ ఆర్డర్లో పోలుస్తుంది:
0రిటర్న్ అయితే: రెండు స్ట్రింగ్లు ఖచ్చితంగా సమానం!< 0(నెగెటివ్) అయితే: డిక్షనరీలోs1ముందు వస్తుంది.> 0(పాజిటివ్) అయితే: డిక్షనరీలోs2ముందు వస్తుంది.
#include <stdio.h>
#include <string.h>
int main() {
char pass1[] = "Secret@123";
char pass2[] = "Secret@123";
char pass3[] = "Admin@999";
if (strcmp(pass1, pass2) == 0) {
printf("✅ pass1 మరియు pass2 సరిగ్గా మ్యాచ్ అయ్యాయి!\n");
}
if (strcmp(pass1, pass3) != 0) {
printf("❌ pass1 మరియు pass3 వేర్వేరు పాస్వర్డ్లు!\n");
}
return 0;
}
నిజ జీవితంలో ఒక కామాతో వేరు చేయబడిన ఫైల్ (CSV) లేదా వాక్యాన్ని పదాలుగా విడదీయవలసి వచ్చినప్పుడు strtok() అమితంగా ఉపయోగపడుతుంది:
#include <stdio.h>
#include <string.h>
int main() {
// కామాలతో కూడిన విద్యార్థి రికార్డు: ID,Name,Course,City
char record[] = "101,సురేష్ కుమార్,కంప్యూటర్ సైన్స్,విశాఖపట్నం";
printf("=== CSV రికార్డ్ పార్సింగ్ (Parsing with strtok) ===\n");
char *token = strtok(record, ","); // మొదటి టోకెన్
int fieldNum = 1;
while (token != NULL) {
printf("ఫీల్డ్ #%d: %s\n", fieldNum++, token);
token = strtok(NULL, ","); // తర్వాతి టోకెన్లను పొందడానికి NULL పాస్ చేయాలి!
}
return 0;
}
ఇప్పటివరకు నేర్చుకున్న fgets, strcmp, strlen, మరియు క్యారెక్టర్ చెకింగ్ ఫంక్షన్స్ ఉపయోగించి ఒక కార్పొరేట్ సెక్యూర్ యూజర్ క్రెడెన్షియల్ ఆథెంటికేషన్ & పాస్వర్డ్ స్ట్రెంగ్త్ చెకర్ (Security Engine) నిర్మిద్దాం:
#include <stdio.h>
#include <string.h>
#include <ctype.h>
// పాస్వర్డ్ పటిష్టతను తనిఖీ చేసే ఫంక్షన్
int checkPasswordStrength(const char *pwd) {
if (strlen(pwd) < 8) {
printf("⚠️ బలహీనమైన పాస్వర్డ్: కనీసం 8 అక్షరాలు ఉండాలి!\n");
return 0;
}
int hasUpper = 0, hasDigit = 0, hasSpecial = 0;
for (int i = 0; pwd[i] != '\0'; i++) {
if (isupper(pwd[i])) hasUpper = 1;
else if (isdigit(pwd[i])) hasDigit = 1;
else if (ispunct(pwd[i])) hasSpecial = 1;
}
if (hasUpper && hasDigit && hasSpecial) {
printf("💪 అద్భుతమైన పాస్వర్డ్: చాలా పటిష్టంగా ఉంది (Strong Password)!\n");
return 1;
} else {
printf("⚠️ మధ్యస్థ పాస్వర్డ్: క్యాపిటల్ లెటర్, నంబర్ మరియు స్పెషల్ క్యారెక్టర్ జోడించండి.\n");
return 0;
}
}
int main() {
const char correctUser[] = "admin_mana";
const char correctPass[] = "Secure@2026";
char enteredUser[32];
char enteredPass[32];
printf("====================================================\n");
printf(" మనా సెక్యూరిటీ పోర్టల్ లాగిన్ (Security Portal)\n");
printf("====================================================\n");
printf("యూజర్నేమ్: ");
fgets(enteredUser, sizeof(enteredUser), stdin);
enteredUser[strcspn(enteredUser, "\n")] = '\0'; // న్యూలైన్ తొలగింపు
printf("పాస్వర్డ్ : ");
fgets(enteredPass, sizeof(enteredPass), stdin);
enteredPass[strcspn(enteredPass, "\n")] = '\0';
printf("\n[ఆడిట్] పాస్వర్డ్ పరిశీలన జరుగుతోంది...\n");
checkPasswordStrength(enteredPass);
printf("----------------------------------------------------\n");
if (strcmp(enteredUser, correctUser) == 0 && strcmp(enteredPass, correctPass) == 0) {
printf("✅ లాగిన్ విజయవంతమైంది! సిస్టమ్ డాష్బోర్డ్ అన్లాక్ చేయబడింది.\n");
} else {
printf("🚨 లాగిన్ విఫలమైంది: తప్పుడు యూజర్నేమ్ లేదా పాస్వర్డ్!\n");
}
printf("====================================================\n");
return 0;
}
"INDIA" కోసం
char s[5] = "INDIA"; అని రాస్తే నల్ టెర్మినేటర్ పట్టక బఫర్ ఓవర్ఫ్లో వస్తుంది. char s[6] తప్పనిసరి.
if (s1 == s2) అని రాస్తే అది అడ్రస్లను పోలుస్తుంది తప్ప కంటెంట్ను కాదు. ఎల్లప్పుడూ strcmp() వాడాలి.
gets() తీవ్రమైన సెక్యూరిటీ బగ్. దాని స్థానంలో ఎల్లప్పుడూ సురక్షితమైన fgets() మాత్రమే వాడాలి.
char *p = "Hello"; p[0] = 'M'; అని రాస్తే ఆపరేటింగ్ సిస్టమ్ సెగ్మెంటేషన్ ఫాల్ట్ ఇస్తుంది. మార్పుల కోసం char p[] వాడాలి.
చిన్న అర్రేలోకి పెద్ద స్ట్రింగ్ను కాపీ చేస్తే మెమరీ కరప్ట్ అవుతుంది. పరిమితిని నిర్దేశించే
strncpy వాడటం ఉత్తమం.
ఈ పాఠంలోని లోతైన అంశాలను క్రింది 5 ప్రాక్టికల్ ప్రశ్నల ద్వారా పరీక్షించుకోండి:
❓ ప్రశ్న 1: C స్ట్రింగ్స్ లో నల్ టెర్మినేటర్ '\0' యొక్క పాత్ర ఏమిటి?
'\0' (ASCII 0) ను ముగింపు చిహ్నంగా ఉపయోగిస్తారు. ఇది లేకపోతే స్ట్రింగ్ ఫంక్షన్లు మెమరీలో ఆగకుండా గార్బేజ్ డేటాను చదువుతాయి.
❓ ప్రశ్న 2: strlen("Hello\0World") యొక్క అవుట్పుట్ ఎంత వస్తుంది?
strlen() మొదటి '\0' తారసపడగానే లెక్కింపును ఆపేస్తుంది. ఆ తర్వాత ఉన్న "World" ను విస్మరిస్తుంది.
❓ ప్రశ్న 3: C11 స్టాండర్డ్ లో gets() ఫంక్షన్ను ఎందుకు పూర్తిగా తొలగించారు?
gets() కు బఫర్ సైజు పరిమితిని తనిఖీ చేసే సామర్థ్యం లేదు. ఇది తీవ్రమైన బఫర్ ఓవర్ఫ్లో సెక్యూరిటీ లోపాలకు దారితీస్తుంది కాబట్టి C11 నుండి శాశ్వతంగా నిషేధించారు.
❓ ప్రశ్న 4: strcmp(s1, s2) రెండు స్ట్రింగ్లు సమానమైనప్పుడు ఏ విలువను రిటర్న్ చేస్తుంది?
❓ ప్రశ్న 5: char str[10] = "Code"; ఉన్నప్పుడు sizeof(str) మరియు strlen(str) విలువల తేడా ఏమిటి?
strlen(str) = 4 (అసలైన అక్షరాలు); sizeof(str) = 10 (అర్రేకు కేటాయించిన మొత్తం మెమరీ బైట్లు).
పైన వివరించిన పాస్వర్డ్ స్ట్రెంగ్త్ చెకర్ మరియు strtok CSV పార్సర్ కోడ్లను మన ఆన్లైన్ C కంపైలర్లో ఓపెన్ చేసి స్వయంగా రన్ చేయండి. మీ స్వంత యూజర్ క్రెడెన్షియల్స్తో టెస్ట్ చేసి ఆనందించండి!
📌 అధ్యాయ సారాంశం (Quick Summary):
- C స్ట్రింగ్స్: నల్ టెర్మినేటర్
'\0'తో ముగిసే క్యారెక్టర్ల అర్రే. - +1 బైట్ రూల్: ఏ పదానికైనా అదనంగా 1 బైట్
'\0'కోసం కేటాయించాలి. - సేఫ్ ఇన్పుట్:
scanfమరియుgetsబదులుగా ఎల్లప్పుడూfgets()వాడాలి. - <string.h>:
strlen(పొడవు),strcpy(కాపీ),strcat(కలపడం),strcmp(పోల్చడం). - స్ట్రింగ్ లిటరల్స్:
char *s = "Hello"రీడ్-ఓన్లీ మెమరీలో ఉంటుంది, సవరించకూడదు.