వాక్యనిర్మాణం:
చార్* strcpy (చార్*గమ్యం_స్థానం, కానిస్టేట్ చార్*మూలం_ స్ట్రింగ్);Strcpy () ను అర్థం చేసుకోవడం:
Strcpy () ఫంక్షన్ యొక్క ఏకైక ఉద్దేశ్యం స్ట్రింగ్‌ను మూలం నుండి గమ్యస్థానానికి కాపీ చేయడం. ఇప్పుడు, strcpy () ఫంక్షన్ యొక్క పై వాక్యనిర్మాణాన్ని చూద్దాం. Strcpy () ఫంక్షన్ రెండు పారామితులను అంగీకరించగలదు -
- char * గమ్యం
- const char * మూలం
Strcpy () ఫంక్షన్ సోర్స్ స్ట్రింగ్‌ని మార్చలేదని నిర్ధారించడానికి మూలం ఇక్కడ స్థిరంగా ఉంటుంది. Strcpy () ఫంక్షన్ సోర్స్ స్ట్రింగ్ నుండి గమ్యస్థానానికి అన్ని అక్షరాలను (స్ట్రింగ్ చివరిలో NULL అక్షరంతో సహా) కాపీ చేస్తుంది. కాపీ ఆపరేషన్ మూలం నుండి గమ్యస్థానానికి పూర్తయిన తర్వాత, strcpy () ఫంక్షన్ గమ్యం యొక్క చిరునామాను కాలర్ ఫంక్షన్‌కు తిరిగి అందిస్తుంది.
ఇక్కడ గమనించాల్సిన ముఖ్యమైన విషయం ఏమిటంటే, strcpy () ఫంక్షన్ గమ్యం స్ట్రింగ్‌తో సోర్స్ స్ట్రింగ్‌ని జోడించదు. ఇది సోర్స్ స్ట్రింగ్ కంటెంట్‌తో గమ్యం యొక్క కంటెంట్‌ని భర్తీ చేస్తుంది.
అలాగే, గమ్యం యొక్క పరిమాణం సోర్స్ స్ట్రింగ్ కంటే ఎక్కువగా ఉందని నిర్ధారించడానికి strcpy () ఫంక్షన్ ఎటువంటి తనిఖీలు చేయదు, ఇది పూర్తిగా ప్రోగ్రామర్ బాధ్యత.
ఉదాహరణలు:
ఇప్పుడు, strcpy () ఫంక్షన్‌ను అర్థం చేసుకోవడానికి మేము అనేక ఉదాహరణలను చూస్తాము:
- strcpy () - సాధారణ ఆపరేషన్ (ఉదాహరణ 1. సి)
- strcpy ()-కేసు -1 (ఉదాహరణ 2. c)
- strcpy ()-కేసు -2 (ఉదాహరణ 3. c)
- strcpy ()-కేస్ -3 (ఉదాహరణ 4..సి)
- strcpy () - యూజర్ నిర్వచించిన వెర్షన్ (ఉదాహరణ 5. c)
- strcpy () - యూజర్ నిర్వచించిన వెర్షన్ ఆప్టిమైజ్ చేయబడింది (ఉదాహరణ 6.. సి)
strcpy () - సాధారణ ఆపరేషన్ (example1.c):
సి ప్రోగ్రామింగ్ లాంగ్వేజ్‌లోని strcpy () ఫంక్షన్‌ను ఉపయోగించి సాధారణ స్ట్రింగ్ కాపీ ఆపరేషన్‌ను ఎలా నిర్వహించాలో ఈ ఉదాహరణ ప్రోగ్రామ్ చూపుతుంది. గమ్యస్థానం స్ట్రింగ్ యొక్క పొడవు 30 (చార్ డెస్టినేషన్_స్ట్రార్ [30];), ఇది మూలం స్ట్రింగ్ పొడవు కంటే ఎక్కువ (పొడవు మొత్తం 18 అక్షరాలు) కాబట్టి గమ్యం నుండి అన్ని అక్షరాలు ఉంటాయి మూలం స్ట్రింగ్.
#చేర్చండి
#చేర్చండి
intప్రధాన()
{
చార్source_str[] = 'www.linuxhint.com';
చార్గమ్యం_స్టార్[30];
printf ('Strcpy () ఫంక్షన్‌కు కాల్ చేయడానికి ముందు: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
printf (' tగమ్యం స్ట్రింగ్ = %s n n',గమ్యం_స్టార్);
strcpy (గమ్యం_స్టార్,source_str);
printf ('Strcpy () ఫంక్షన్‌ను అమలు చేసిన తర్వాత: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
printf (' tగమ్యం స్ట్రింగ్ = %s n n',గమ్యం_స్టార్);
తిరిగి 0;
}
strcpy ()-కేసు -1 (example2.c):
ఈ ఉదాహరణ ప్రోగ్రామ్ యొక్క ఉద్దేశ్యం గమ్యం స్ట్రింగ్ యొక్క పొడవు సోర్స్ స్ట్రింగ్ పొడవు కంటే తక్కువగా ఉన్నప్పుడు ఏమి జరుగుతుందో స్పష్టంగా వివరించడం. అటువంటి సందర్భాలలో, సోర్స్ స్ట్రింగ్ నుండి అన్ని అక్షరాలు (NULL అక్షరంతో సహా) ఉంచడానికి గమ్య స్థానానికి తగినంత ఖాళీలు/బైట్‌లు ఉండవు. రెండు విషయాలు, మీరు ఎల్లప్పుడూ గుర్తుంచుకోవాలి:
- గమ్యస్థానానికి తగినంత స్థలం ఉందో లేదో strcpy () ఫంక్షన్ తనిఖీ చేయదు.
- ఎంబెడెడ్ సాఫ్ట్‌వేర్‌లో ఇది ప్రమాదకరంగా ఉండవచ్చు ఎందుకంటే strcpy () గమ్యస్థాన సరిహద్దుకు మించిన మెమరీ ప్రాంతాన్ని భర్తీ చేస్తుంది.
ఉదాహరణ కార్యక్రమాన్ని చూద్దాం. మేము source_str ని ప్రకటించాము మరియు దానిని ప్రారంభిస్తాము www.linuxhint.com , స్ట్రింగ్ చివర నల్ క్యారెక్టర్‌తో సహా స్టోర్ చేయడానికి 18 బైట్‌లు మెమరీలో పడుతుంది. అప్పుడు, మేము మరొక అక్షర శ్రేణిని ప్రకటించాము, అంటే గమ్యం_ఎస్‌టిఆర్ కేవలం 5 పరిమాణంతో, కాబట్టి గమ్యం_స్ట్ర్ మొత్తం 18 బైట్‌ల పరిమాణంతో సోర్స్ స్ట్రింగ్‌ని కలిగి ఉండదు.
కానీ, ఇప్పటికీ, గమ్యం స్ట్రింగ్‌కు సోర్స్ స్ట్రింగ్‌ని కాపీ చేయడానికి మేము strcpy () ఫంక్షన్‌కు కాల్ చేస్తున్నాము. దిగువ అవుట్‌పుట్ నుండి, మేము strcpy () అస్సలు ఫిర్యాదు చేయలేదని చూడవచ్చు. ఈ సందర్భంలో, strcpy () ఫంక్షన్ మూలాధార స్ట్రింగ్ నుండి అక్షరాన్ని కాపీ చేయడం ప్రారంభిస్తుంది (సోర్స్ స్ట్రింగ్‌లో NULL అక్షరాన్ని కనుగొనే వరకు) గమ్యం చిరునామాకు (గమ్యం సరిహద్దు మించినప్పటికీ). అంటే strcpy () ఫంక్షన్ గమ్యం శ్రేణి కోసం సరిహద్దు తనిఖీ చేయదు. చివరికి, గమ్య శ్రేణికి కేటాయించని మెమరీ చిరునామాలను strcpy () ఫంక్షన్ భర్తీ చేస్తుంది. అందుకే strcpy () ఫంక్షన్ వేరే వేరియబుల్‌కు కేటాయించబడే మెమరీ స్థానాలను భర్తీ చేస్తుంది.
ఈ ఉదాహరణలో, strcpy () ఫంక్షన్ సోర్స్ స్ట్రింగ్‌ని ఓవర్రైట్ చేస్తుంది అని మనం దిగువ అవుట్‌పుట్ నుండి చూడవచ్చు. ప్రోగ్రామర్లు ఎల్లప్పుడూ అలాంటి ప్రవర్తనతో జాగ్రత్తగా ఉండాలి.
#చేర్చండి#చేర్చండి
intప్రధాన()
{
చార్source_str[] = 'www.linuxhint.com';
చార్గమ్యం_స్టార్[5];
printf ('Strcpy () ఫంక్షన్‌కు కాల్ చేయడానికి ముందు: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
printf (' tగమ్యం స్ట్రింగ్ = %s n n',గమ్యం_స్టార్);
strcpy (గమ్యం_స్టార్,source_str);
printf ('Strcpy () ఫంక్షన్‌ను అమలు చేసిన తర్వాత: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
printf (' tగమ్యం స్ట్రింగ్ = %s n n',గమ్యం_స్టార్);
// printf ('మూల చిరునామా = %u (0x %x) n', & source_str [0], & source_str [0]);
// printf ('గమ్య చిరునామా = %u (0x %x) n', & destination_str [0], & destination_str [0]);
తిరిగి 0;
}
strcpy ()-కేసు -2 (ఉదాహరణ 3. c):
గమ్యం స్ట్రింగ్ పరిమాణం మూలం స్ట్రింగ్ పరిమాణం కంటే ఎక్కువగా ఉన్నప్పుడు మరియు గమ్యం స్ట్రింగ్ ఇప్పటికే కొంత విలువతో ప్రారంభించినప్పుడు ఈ కార్యక్రమం పరిస్థితిని వివరిస్తుంది. ఈ ఉదాహరణలో, మేము ప్రారంభించాము:
- మూలం_స్ట్ర్‌కి www.linuxhint.com [పరిమాణం = 17+1 = 18]
- I_AM_A_DESTINATION_STRING కి గమ్యం_స్టార్ [size = 25+1 = 26]
Strcpy () ఫంక్షన్ మొత్తం 17 అక్షరాలను మరియు మూలం స్ట్రింగ్ నుండి గమ్యం స్ట్రింగ్‌కు NULL అక్షరాన్ని కాపీ చేస్తుంది. కానీ, ఇది గమ్య శ్రేణిలో మిగిలిన బైట్‌లను (బైట్ 19 నుండి 26, ఒక ఆధారిత) భర్తీ చేయదు/మార్చదు. గమ్యస్థాన శ్రేణిపై మళ్ళించడానికి మరియు మొత్తం శ్రేణిని ముద్రించడానికి మేము లూప్ కోసం ఉపయోగించాము, గమ్య శ్రేణిలో బైట్‌లు -19 నుండి 26 వరకు మారవు. అందుకే మేము చివరి అవుట్‌పుట్‌ను ఇలా చూస్తాము:
#చేర్చండి#చేర్చండి
/* ఈ ప్రోగ్రామ్ పరిస్థితిని వివరిస్తుంది:
గమ్యం స్ట్రింగ్ పరిమాణం> మూలం స్ట్రింగ్ పరిమాణం
మరియు మేము కాపీ చేయడానికి strcpy () ఫంక్షన్‌ను అమలు చేస్తాము
గమ్యానికి సోర్స్ స్ట్రింగ్.
గమనిక: గమ్యం స్ట్రింగ్ పరిమాణం ఎల్లప్పుడూ ఉండాలి
మూల స్ట్రింగ్ కంటే ఎక్కువ లేదా సమానంగా ఉంటుంది.
* /
intప్రధాన()
{
చార్source_str[] = 'www.linuxhint.com';
చార్గమ్యం_స్టార్[26] = 'I_AM_A_DESTINATION_STRING';
printf ('Strcpy () ఫంక్షన్‌కు కాల్ చేయడానికి ముందు: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
printf (' tగమ్యం స్ట్రింగ్ = %s n n',గమ్యం_స్టార్);
strcpy (గమ్యం_స్టార్,source_str);
printf ('Strcpy () ఫంక్షన్‌ను అమలు చేసిన తర్వాత: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
printf (' tగమ్యం స్ట్రింగ్ = %s n n',గమ్యం_స్టార్);
/* లూప్ కోసం గమ్యం స్ట్రింగ్‌ను ముద్రించండి*/
printf ('గమ్యం స్ట్రింగ్ చార్‌ను చార్ ద్వారా ముద్రించండి: n n');
printf (' tగమ్యం స్ట్రింగ్ = ');
కోసం(inti=0;i<25;i++)
{
printf ('% c',గమ్యం_స్టార్[i]);
}
printf (' n n');
తిరిగి 0;
}
strcpy ()-కేసు -3 (example4.c):
గమ్యస్థానంగా స్ట్రింగ్ సాహిత్యంతో మేము ఎన్నడూ strcpy () అని పిలవకూడదని చూపించడానికి మేము ఈ ప్రోగ్రామ్‌ను ఉదాహరణగా పరిగణించాము. ఇది నిర్వచించబడని ప్రవర్తనకు కారణమవుతుంది మరియు చివరికి, ప్రోగ్రామ్ క్రాష్ అవుతుంది.
#చేర్చండి#చేర్చండి
intప్రధాన()
{
చార్source_str[] = 'www.linuxhint.com';
printf ('Strcpy () ఫంక్షన్‌కు కాల్ చేయడానికి ముందు: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
/* స్ట్రింగ్ సాహిత్యంతో గమ్యస్థానంగా strcpy () ని ఎప్పుడూ పిలవవద్దు.
కార్యక్రమం క్రాష్ అవుతుంది.
* /
strcpy ('destination_str',source_str);
printf ('Strcpy () ఫంక్షన్‌ను అమలు చేసిన తర్వాత: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
తిరిగి 0;
}
strcpy () - యూజర్ డిఫైన్డ్ వెర్షన్ (example5.c):
ఈ ఉదాహరణ ప్రోగ్రామ్‌లో, strcpy () ఫంక్షన్ యొక్క వినియోగదారు నిర్వచించిన సంస్కరణను ఎలా వ్రాయాలో మేము చూపించాము.
#చేర్చండిచార్ *strcpy_user_ నిర్వచించబడింది(చార్ *గమ్యం, కానిస్టేట్ చార్ *src);
/ * Strcpy () ఫంక్షన్ యొక్క వినియోగదారు నిర్వచించిన వెర్షన్ */
చార్ *strcpy_user_ నిర్వచించబడింది(చార్ *గమ్యం, కానిస్టేట్ చార్ *src)
{
చార్ *dest_backup=గమ్యం;
అయితే(*src! = ' 0') /* ' 0' కనుగొనబడే వరకు పునరావృతం చేయండి.*/
{
*గమ్యం= *src; / * సోర్స్ చార్‌ను గమ్యస్థానానికి కాపీ చేయండి */
src++; / * ఇంక్రిమెంట్ సోర్స్ పాయింటర్ */
గమ్యం++; / * ఇంక్రిమెంట్ గమ్యం పాయింటర్ */
}
*గమ్యం= ' 0'; /* గమ్యస్థానంలో ' 0' ని స్పష్టంగా చొప్పించండి*/
తిరిగిdest_backup;
}
intప్రధాన()
{
చార్source_str[] = 'www.linuxhint.com';
చార్గమ్యం_స్టార్[30];
printf (వినియోగదారు నిర్వచించిన స్ట్రింగ్ కాపీ ఫంక్షన్‌కు కాల్ చేయడానికి ముందు: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
printf (' tగమ్యం స్ట్రింగ్ = %s n n',గమ్యం_స్టార్);
/ * వినియోగదారుని నిర్వచించిన స్ట్రింగ్ కాపీ ఫంక్షన్ */
strcpy_user_ నిర్వచించబడింది(గమ్యం_స్టార్,source_str);
printf (వినియోగదారు నిర్వచించిన స్ట్రింగ్ కాపీ ఫంక్షన్‌ను అమలు చేసిన తర్వాత: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
printf (' tగమ్యం స్ట్రింగ్ = %s n n',గమ్యం_స్టార్);
తిరిగి 0;
}
strcpy () - యూజర్ నిర్వచించిన వెర్షన్ ఆప్టిమైజ్ చేయబడింది (ఉదాహరణ 6..సి):
ఇప్పుడు, ఈ ఉదాహరణ ప్రోగ్రామ్‌లో, మేము strcpy () యొక్క వినియోగదారు నిర్వచించిన వెర్షన్‌ను ఆప్టిమైజ్ చేయబోతున్నాం.
#చేర్చండిచార్ *strcpy_user_ నిర్వచించబడింది(చార్ *గమ్యం, కానిస్టేట్ చార్ *src);
/ * వినియోగదారు నిర్వచించిన strcpy () ఫంక్షన్ యొక్క ఆప్టిమైజ్ వెర్షన్ */
చార్ *strcpy_user_ నిర్వచించబడింది(చార్ *గమ్యం, కానిస్టేట్ చార్ *src)
{
చార్ *dest_backup=గమ్యం;
అయితే(*గమ్యం++ = *src++)
;
తిరిగిdest_backup;
}
intప్రధాన()
{
చార్source_str[] = 'www.linuxhint.com';
చార్గమ్యం_స్టార్[30];
printf (వినియోగదారు నిర్వచించిన స్ట్రింగ్ కాపీ ఫంక్షన్‌కు కాల్ చేయడానికి ముందు: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
printf (' tగమ్యం స్ట్రింగ్ = %s n n',గమ్యం_స్టార్);
/ * వినియోగదారుని నిర్వచించిన స్ట్రింగ్ కాపీ ఫంక్షన్ */
strcpy_user_ నిర్వచించబడింది(గమ్యం_స్టార్,source_str);
printf (వినియోగదారు నిర్వచించిన స్ట్రింగ్ కాపీ ఫంక్షన్‌ను అమలు చేసిన తర్వాత: n n');
printf (' tమూల స్ట్రింగ్ = %s n',source_str);
printf (' tగమ్యం స్ట్రింగ్ = %s n n',గమ్యం_స్టార్);
తిరిగి 0;
}
ముగింపు :
C ప్రోగ్రామింగ్ భాషలో స్ట్రింగ్ కాపీ ఆపరేషన్ చేయడానికి strcpy () ఫంక్షన్ చాలా ప్రజాదరణ పొందిన మరియు సులభమైన లైబ్రరీ ఫంక్షన్. స్ట్రింగ్‌ను ఒక ప్రదేశం నుండి మరొక ప్రదేశానికి కాపీ చేయడానికి ఇది ప్రధానంగా ఉపయోగించబడుతుంది. అయినప్పటికీ, గమ్యస్థాన శ్రేణి కోసం strcpy () ఫంక్షన్ సరిహద్దు తనిఖీ చేయదు అనే వాస్తవాన్ని మేము పునరుద్ఘాటించాలనుకుంటున్నాము, ఇది నిర్లక్ష్యం చేస్తే తీవ్రమైన సాఫ్ట్‌వేర్ బగ్‌కు దారితీస్తుంది. పూర్తి అక్షరంతో సహా సోర్స్ స్ట్రింగ్ నుండి అన్ని అక్షరాలను పట్టుకోవడానికి గమ్య శ్రేణికి తగినంత స్థలం ఉందని నిర్ధారించుకోవడం ఎల్లప్పుడూ ప్రోగ్రామర్ యొక్క బాధ్యత.