“సి ప్రోగ్రామింగ్ ప్రాథమిక ప్రోగ్రామింగ్ భాష. ఆపరేటింగ్ సిస్టమ్‌లు, డేటాబేస్‌లు మొదలైన విభిన్న సాఫ్ట్‌వేర్‌లను అభివృద్ధి చేయడానికి మేము ఈ సి ప్రోగ్రామింగ్ భాషను సులభంగా ఉపయోగించుకోవచ్చు. ఇది పూర్ణాంకం, ఫ్లోట్ మరియు చార్ వంటి విభిన్న డేటా రకాలను అందిస్తుంది. C ప్రోగ్రామింగ్‌లోని స్ట్రింగ్ అనేది శూన్య విలువతో ముగిసే అక్షరాల సేకరణ. మేము C ప్రోగ్రామింగ్‌లో స్ట్రింగ్‌ను సులభంగా ప్రకటించవచ్చు, ప్రారంభించవచ్చు మరియు ప్రింట్ చేయవచ్చు. మేము స్ట్రింగ్‌ను C లో కూడా కాపీ చేయవచ్చు. మేము స్ట్రింగ్‌ను నమోదు చేయాలనుకున్నప్పుడు, దానిని డబుల్ కోట్స్‌లో వ్రాయాలి మరియు మనం ఒకే అక్షరాన్ని జోడించాల్సిన అవసరం వచ్చినప్పుడు, మేము సింగిల్ కోట్‌లను ఉపయోగిస్తాము. ఈ గైడ్‌లో C ప్రోగ్రామింగ్‌లో స్ట్రింగ్‌ను ఎలా డిక్లేర్ చేయాలో, ప్రారంభించాలో, ప్రింట్ చేయాలో మరియు కాపీ చేయాలో మేము చూపుతాము.
C లో స్ట్రింగ్‌ను ప్రకటించడం
సి ప్రోగ్రామింగ్‌లో స్ట్రింగ్‌ను డిక్లేర్ చేయవలసి వచ్చినప్పుడు, మనం తప్పనిసరిగా క్యారెక్టర్ అర్రేని ఉపయోగించాలి. మొదట, మేము 'చార్' అని వ్రాస్తాము, ఇది డేటా రకం, ఆపై స్ట్రింగ్ పేరును నమోదు చేయండి. అలాగే, స్ట్రింగ్ పేరును ఉంచిన తర్వాత స్క్వేర్ బ్రాకెట్లలో స్ట్రింగ్ పరిమాణం ఇవ్వబడుతుంది. ఇక్కడ ఈ చిత్రంలో, మేము స్ట్రింగ్ యొక్క వాక్యనిర్మాణాన్ని ఇక్కడ ఉంచినట్లు మీరు గమనించవచ్చు. మేము స్ట్రింగ్ యొక్క పరిమాణాన్ని నమోదు చేయాలనుకుంటే, అది ఈ స్క్వేర్ బ్రాకెట్ల లోపల జోడించబడుతుంది మరియు ఇక్కడ ఎలాంటి స్ట్రింగ్ పరిమాణాన్ని నిర్వచించకుండానే ఈ స్ట్రింగ్‌ను ప్రకటించవచ్చు.
C లో స్ట్రింగ్‌ను ప్రారంభించడం
మేము C ప్రోగ్రామింగ్‌లో స్ట్రింగ్‌ను కూడా ప్రారంభించవచ్చు మరియు ఇది C లో స్ట్రింగ్‌ను ప్రారంభించడం కోసం నాలుగు విభిన్న మార్గాలను అందిస్తుంది. అన్ని పద్ధతులు క్రింద చూపబడ్డాయి.
స్ట్రింగ్ పరిమాణాన్ని పేర్కొనకుండా స్ట్రింగ్‌ను ప్రారంభించడం:
ఇక్కడ చూపిన విధంగా మనం పరిమాణాన్ని పేర్కొనకుండా స్ట్రింగ్‌ను ప్రారంభించవచ్చు. మేము స్క్వేర్ బ్రాకెట్ల లోపల సంఖ్యలలో ఏ పరిమాణాన్ని జోడించలేదు. మేము ఖాళీ స్క్వేర్ బ్రాకెట్‌లను ఉంచి, ఆపై ఇక్కడ “నా మొదటి స్ట్రింగ్” అనే స్ట్రింగ్‌తో ప్రారంభించాము.
పరిమాణాన్ని పేర్కొనడం ద్వారా స్ట్రింగ్‌ను ప్రారంభించడం:
చూపిన విధంగా, స్క్వేర్ బ్రాకెట్లలో స్ట్రింగ్ పరిమాణాన్ని పేర్కొనడం ద్వారా మనం C లో స్ట్రింగ్‌ను ప్రారంభించవచ్చు. మేము స్క్వేర్ బ్రాకెట్ల లోపల '20'ని జోడించాము మరియు ఇది ఈ స్ట్రింగ్ పరిమాణం. దీని తరువాత, మేము దానిని 'నా మొదటి స్ట్రింగ్'తో ప్రారంభించాము. ఇప్పుడు, ఈ స్ట్రింగ్ ఇక్కడ ప్రారంభించబడింది.
అక్షరం ద్వారా అక్షరాన్ని చొప్పించడం మరియు పరిమాణాన్ని పేర్కొనడం ద్వారా స్ట్రింగ్‌ను ప్రారంభించడం:
ఈ స్ట్రింగ్‌లో అక్షరాలను కేటాయించడం ద్వారా స్ట్రింగ్ కూడా ప్రారంభించబడుతుంది. మేము స్ట్రింగ్ పరిమాణంగా “16”ని జోడించాము, ఆపై చూపిన విధంగా ఒక్కో అక్షరాన్ని ఒకే కోట్‌ల లోపల ఉంచడం ద్వారా మేము అక్షరాలను జోడించాము. మేము ఈ స్ట్రింగ్‌ను విభిన్న అక్షరాలతో ప్రారంభించాము. ఈ అక్షరాలు కర్లీ బ్రాకెట్లలో జోడించబడ్డాయి మరియు ప్రతి అక్షరం ఒకే కోట్‌లలో జతచేయబడుతుంది. మనం చివర “\0”ని తప్పనిసరిగా జోడించాలి.
పరిమాణాన్ని పేర్కొనకుండా అక్షరాలను కేటాయించడం ద్వారా స్ట్రింగ్‌ను ప్రారంభించడం:
మేము ఇక్కడ స్ట్రింగ్ యొక్క ఏ పరిమాణాన్ని జోడించలేదు. మేము స్ట్రింగ్ పరిమాణాన్ని పేర్కొనకుండా ఇక్కడ అక్షరాన్ని కేటాయిస్తాము. అలాగే, చివర్లో శూన్య అక్షరాన్ని జోడించాము. స్ట్రింగ్ కూడా ఈ విధంగా ప్రారంభించబడింది.
C లో స్ట్రింగ్‌ను ముద్రించడం
C ప్రోగ్రామింగ్‌లో స్ట్రింగ్‌ను ప్రింట్ చేయడం కోసం, మనం “printf” ఫంక్షన్‌ని ఉపయోగించుకోవచ్చు మరియు “
ఉదాహరణ # 1
“printf” స్టేట్‌మెంట్ మనం ప్రకటించిన మరియు ప్రారంభించిన స్ట్రింగ్‌ను ప్రింట్ చేయడంలో సహాయపడుతుంది. ముందుగా, మేము హెడర్ ఫైల్‌ని చేర్చాము, ఇది ఇన్‌పుట్/అవుట్‌పుట్ ఫంక్షన్‌లను ఉపయోగించడంలో సహాయపడుతుంది. అప్పుడు, మేము 'ప్రధాన ()' ఫంక్షన్ అని పిలుస్తాము. దీని తర్వాత, మేము ఎటువంటి స్ట్రింగ్ పరిమాణాన్ని పేర్కొనకుండా ఇక్కడ స్ట్రింగ్‌ను ప్రకటించాము మరియు ప్రారంభించాము మరియు ఈ స్ట్రింగ్‌కు అక్షరాలను కేటాయించాము. దిగువన, మేము స్ట్రింగ్‌ను ప్రింట్ చేయడానికి “printf” స్టేట్‌మెంట్‌ను ఉపయోగించాము. ఈ “printf” ఫంక్షన్‌కి మనం స్ట్రింగ్ పేరును పాస్ చేసినప్పుడు మాత్రమే ఈ స్ట్రింగ్ ప్రింట్ చేయబడుతుంది.
మేము 'F9' కీని ఉపయోగించి ఈ కోడ్‌ని కంపైల్ చేసాము, ఆపై 'F10' కీని నొక్కడం ద్వారా మేము దీన్ని అమలు చేసాము. విజయవంతమైన సంకలనం మరియు అమలు తర్వాత, మేము ఈ ఫలితాన్ని పొందుతాము, అది కూడా క్రింద చూపబడింది. ఇక్కడ, మనం పైన నమోదు చేసిన స్ట్రింగ్ ప్రదర్శించబడుతుంది.
ఉదాహరణ # 2
మేము ఇక్కడ రెండు హెడర్ ఫైల్‌లను చేర్చాము మరియు ఇవి “stdio. h' మరియు 'string.h' ఎందుకంటే మేము రెండు హెడర్ ఫైల్‌ల ఫంక్షన్‌లను ఉపయోగించాలి. దీని తర్వాత, మేము 'int main()' ఫంక్షన్‌ని చొప్పించాము, ఆపై మేము 'my_str' పేరుతో స్ట్రింగ్‌ను ప్రారంభించాము మరియు మేము ఇక్కడ స్ట్రింగ్ యొక్క ఏ పరిమాణాన్ని జోడించలేదు. “my_str”ని ప్రారంభించడం కోసం మేము ఉపయోగించిన స్ట్రింగ్ “String_Data”. మేము “printf”ని ఉపయోగించడం ద్వారా ఈ స్ట్రింగ్‌ను ప్రింట్ చేస్తాము, ఆపై డేటా రకం “int”ని ఉంచడం ద్వారా మేము పూర్ణాంక “l”ని ప్రారంభిస్తాము. దీని తర్వాత, మేము ఈ “l” వేరియబుల్‌కు “strlen()” ఫంక్షన్‌ని కేటాయించాము. మేము ఈ “strlen()” ఫంక్షన్‌కి “my_str” స్ట్రింగ్‌ను పాస్ చేసాము, ఇది స్ట్రింగ్ యొక్క అక్షరాలను లెక్కించి “l” వేరియబుల్‌లో నిల్వ చేస్తుంది. దీని తర్వాత, మేము అదే “printf()” పద్ధతిని ఉపయోగించి ఈ స్ట్రింగ్ యొక్క పొడవును కూడా దిగువన ప్రింట్ చేస్తాము. ఇక్కడ, మేము 'l' వేరియబుల్‌లో నిల్వ చేయబడిన 'my_str' స్ట్రింగ్ పొడవు యొక్క పరిమాణాన్ని ముద్రిస్తున్నాము.
మొదట, ఇది మనం పైన జోడించిన స్ట్రింగ్‌ను ప్రింట్ చేస్తుంది, ఆపై అది అక్షరాలను గణిస్తుంది మరియు స్ట్రింగ్‌లో ఉన్న అక్షరాల సంఖ్యను ప్రదర్శిస్తుంది లేదా ఇక్కడ స్ట్రింగ్ యొక్క పొడవును ప్రదర్శిస్తుందని చెప్పవచ్చు.
C లో స్ట్రింగ్‌ను కాపీ చేయడం
సి ప్రోగ్రామింగ్‌లో వివిధ పద్ధతులను ఉపయోగించడం ద్వారా మనం స్ట్రింగ్‌ను కాపీ చేయవచ్చు. ఇక్కడ మేము C లో స్ట్రింగ్‌ను కాపీ చేయడంలో సహాయపడే రెండు పద్ధతులను చర్చిస్తున్నాము. ఈ పద్ధతులు:
- “strcpy()” పద్ధతిని ఉపయోగించడం ద్వారా.
- memcpy() పద్ధతిని ఉపయోగించడం ద్వారా.
ఉదాహరణ: “strcpy()” పద్ధతిని ఉపయోగించడం ద్వారా
మేము ఈ ఉదాహరణలో రెండు హెడర్ ఫైల్‌లను చేర్చాము మరియు ఇవి “stdio.h” మరియు “string.h”. అప్పుడు, మేము 'ప్రధాన ()' అని పిలిచాము. దీని తర్వాత, మేము ఇక్కడ “my_str_1” పేరుతో ఒక స్ట్రింగ్‌ని ప్రారంభించాము మరియు ఈ “my_str_1”కి “My String in C ప్రోగ్రామింగ్”ని కేటాయించాము. దిగువన, మేము మరొక స్ట్రింగ్‌ను ప్రకటించాము మరియు ఆ స్ట్రింగ్‌ను ప్రారంభించలేదు. రెండవ స్ట్రింగ్ పేరు “my_str_2”. రెండు స్ట్రింగ్‌ల పరిమాణం ఒక్కొక్కటి '30'. అప్పుడు, మేము 'printf'ని ఉపయోగించి మొదటి స్ట్రింగ్‌ను ప్రింట్ చేస్తాము మరియు ఈ స్ట్రింగ్‌ను ప్రింట్ చేసిన తర్వాత, మేము ఇక్కడ 'strcpy()' పద్ధతిని ఉపయోగిస్తాము, ఇది మొదటి స్ట్రింగ్‌ను రెండవ స్ట్రింగ్‌కి కాపీ చేయడంలో సహాయపడుతుంది. ఈ “strcpy()” పద్ధతిలో, మేము స్ట్రింగ్‌ను కాపీ చేయాలనుకుంటున్న స్ట్రింగ్ పేరును పేర్కొన్నాము, ఆపై మనం కాపీ చేయాలనుకుంటున్న స్ట్రింగ్ పేరును ఉంచాము. “my_str_1” స్ట్రింగ్ ఇప్పుడు “my_str_2” స్ట్రింగ్‌కి కాపీ చేయబడింది. దీని తర్వాత, మేము 'my_str_1' స్ట్రింగ్‌ను కాపీ చేసిన 'my_str_2'ని ప్రింట్ చేస్తాము.
అసలైనది, అలాగే కాపీ చేసిన స్ట్రింగ్ ఇక్కడ ప్రదర్శించబడుతుంది. మేము C ప్రోగ్రామింగ్‌లోని “strcpy()” పద్ధతి సహాయంతో ఈ స్ట్రింగ్‌ను కాపీ చేసాము.
ఉదాహరణ: “memcpy()” పద్ధతిని ఉపయోగించడం ద్వారా
ఇప్పుడు, మేము C ప్రోగ్రామింగ్‌లో స్ట్రింగ్‌ను కాపీ చేయడానికి “memcpy()” ఫంక్షన్‌ని ఉపయోగిస్తున్నాము. మేము 's_1' స్ట్రింగ్‌ను 'C ప్రోగ్రామ్‌లో మొదటి స్ట్రింగ్ ఇక్కడ ఉంది'తో ప్రారంభిస్తాము. అప్పుడు, “s_2” స్ట్రింగ్ దీని తర్వాత ఇప్పుడే ప్రకటించబడింది. మేము రెండు తీగల పరిమాణాన్ని '50' ఉంచాము.
దీని తరువాత, మేము “s_1” స్ట్రింగ్‌ను ప్రింట్ చేసి, ఆపై “memcpy()” పద్ధతిని ఉపయోగిస్తాము, దీనిలో స్ట్రింగ్ కాపీ చేయబడిన స్ట్రింగ్ పేరును మరియు ఆపై కాపీ చేయబడిన స్ట్రింగ్ పేరును జోడించాము. అలాగే, “strlen()” పద్ధతి ఇక్కడ జోడించబడింది, దీనిలో మేము మొదటి స్ట్రింగ్ పేరును చొప్పించాము. ఇప్పుడు, మేము స్ట్రింగ్‌ను ప్రింట్ చేయడంలో సహాయపడే “printf”లో “%s”ని ఉపయోగించాము, ఆపై ఈ “printf” పద్ధతిలో “s_2” అని వ్రాయండి.
ఈ ఫలితంలో రెండు స్ట్రింగ్‌లు చూపబడ్డాయి. ఇక్కడ ప్రదర్శించబడే మొదటి స్ట్రింగ్ అసలు స్ట్రింగ్ మరియు రెండవది కాపీ చేయబడిన స్ట్రింగ్.
ముగింపు
C ప్రోగ్రామింగ్‌లోని “స్ట్రింగ్” ఈ గైడ్‌లో పూర్తిగా చర్చించబడింది. C ప్రోగ్రామింగ్‌లో స్ట్రింగ్‌ను ఎలా డిక్లేర్ చేయాలి, ప్రారంభించాలి, ప్రింట్ చేయాలి మరియు కాపీ చేయాలి అని మేము అన్వేషించాము. మొదట, మేము స్ట్రింగ్‌ను ఎలా ప్రకటించాలో వివరించాము, ఆపై మేము స్ట్రింగ్‌ను C లో ప్రారంభించడం కోసం నాలుగు ప్రత్యేక పద్ధతులను వివరించాము. మేము స్ట్రింగ్‌ను ముద్రించిన విభిన్న ఉదాహరణలను కూడా వివరించాము మరియు చూపించాము. మేము ఈ గైడ్‌లో స్ట్రింగ్‌ను Cలో కాపీ చేయడానికి రెండు పద్ధతులను అన్వేషించాము. C ప్రోగ్రామింగ్‌లోని స్ట్రింగ్ యొక్క అన్ని వివరాలు ఈ గైడ్‌లో అందించబడ్డాయి.