ఈ రోజు, మేము C మరియు C++ భాష యొక్క ముఖ్యమైన ఫంక్షన్లలో ఒకదానిని నేర్చుకోబోతున్నాము, ఇది memmove() ఫంక్షన్. అయితే దీనికి ముందు, C మరియు C++ భాషల ప్రాథమికాలను శీఘ్రంగా పరిశీలిద్దాం. C/C++ రెండు భాషల్లో ఏ ఫంక్షన్‌లు ఉన్నాయో కూడా మేము చర్చిస్తాము.
సి ప్రోగ్రామింగ్ లాంగ్వేజ్ సులభం మరియు అన్ని ప్రయోజనాల కోసం చాలా ప్రభావవంతంగా ఉంటుంది. Windows OS, డేటాబేస్‌లు, ఇంటర్‌ప్రెటర్‌లు మరియు ఇతర సాధనాల వంటి సాఫ్ట్‌వేర్ అమలు దానితో సాధ్యమవుతుంది. ప్రారంభకులకు కోడింగ్ నేర్చుకోవడానికి సి గొప్ప భాష. అందుకే సి ప్రోగ్రామింగ్‌ను మాతృభాష అని పిలుస్తారు, ఎందుకంటే ఇది అన్ని ఇతర కంప్యూటర్ భాషలకు పునాదిగా పనిచేస్తుంది. C++ ప్రోగ్రామింగ్ భాష యొక్క పునాది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ (OOP) ఆలోచనలపై ఆధారపడి ఉంటుంది. C++ స్పష్టమైన నిర్మాణాన్ని కలిగి ఉన్నందున వినియోగదారు ప్రోగ్రామ్ సూత్రాలను సులభంగా అభివృద్ధి చేయవచ్చు మరియు అర్థం చేసుకోవచ్చు. C\C++ ప్రోగ్రామింగ్ లాంగ్వేజ్ బహుళ ఫంక్షన్‌లను చేయడంలో మరియు వేరియబుల్‌ను ఒక రకం నుండి మరొకదానికి మార్చడంలో అనూహ్యంగా బహుముఖంగా ఉంటుంది. C/C++ ఫంక్షన్లలో memmove() ఫంక్షన్ ఒకటి.
memmove() ఫంక్షన్ మెమొరీ బ్లాక్‌లోని కంటెంట్‌ల నుండి ఏకకాలంలో 'సంఖ్య' బైట్‌లను బదిలీ చేస్తుంది, ఇది మూలం ద్వారా గమ్యం సూచించిన స్థానానికి సూచించబడుతుంది. మూలం మరియు గమ్యం వస్తువులు అతివ్యాప్తి చెంది, నిర్వచించబడని ప్రవర్తనను ఆపినప్పుడు మాత్రమే memmove() ఫంక్షన్ ప్రయోజనకరంగా ఉంటుంది. మెమ్మోవ్() ఫంక్షన్ గురించి మరింత తెలుసుకోవడానికి, లోతుగా త్రవ్వి, మెమోవ్() ఫంక్షన్‌లో సింటాక్స్ మరియు ఉదాహరణలను ఎలా అమలు చేయాలో చూద్దాం.
సింటాక్స్:
ఇక్కడ ఒకే వ్రాత శైలి మరియు C మరియు C++ భాషల కోసం మెమోవ్() ఫంక్షన్ అమలు. మొదట, మేము 'శూన్యం' కీవర్డ్‌ను వ్రాస్తాము అంటే ఫంక్షన్ ఏ విలువను అందించకపోతే, మేము అమలు చేయాలనుకుంటున్న ఫంక్షన్ పేరును వ్రాస్తాము అది మెమ్మోవ్() ఫంక్షన్. ఫంక్షన్ బ్రాకెట్లలో, మేము గమ్యాన్ని వ్రాస్తాము, తద్వారా 'శూన్యం' కీవర్డ్‌తో 'సం' బైట్‌లను ఉంచవచ్చు. అప్పుడు, మేము 'సంఖ్య' బైట్‌లను పొందే మూల స్థానాన్ని వ్రాస్తాము.
పారామితులు:
చెయ్యి: డేటా కాపీ చేయబడిన నిల్వ స్థానానికి చిరునామా.
src: డేటా కాపీ చేయబడిన నిల్వ స్థానానికి చిరునామా.
గణన: మూలాధారం నుండి గమ్యస్థానానికి కాపీ చేయవలసిన డేటా మొత్తం.
రిటర్న్ విలువ:
బదులుగా, మేము లక్ష్య మెమరీ ప్రాంతానికి చిరునామాను పొందుతాము. Memmove() ఫంక్షన్ ద్వారా డెస్ట్ తిరిగి ఇవ్వబడుతుంది.
ఉదాహరణ 1: C లో Memmove() ఫంక్షన్ అమలు
సి భాష యొక్క మా మొదటి మరియు సరళమైన ఉదాహరణను అమలు చేయడం ప్రారంభిద్దాం. రాయడం ప్రారంభించడానికి, మనకు మొదట C కంపైలర్ అవసరం, తద్వారా మనం ప్రోగ్రామ్‌ను వ్రాసి అమలు చేయవచ్చు. దాని కోసం, సి కంపైలర్‌ని తెరిచి, ప్రోగ్రామ్‌ను అమలు చేయడం ప్రారంభించండి.
##include
పూర్ణాంక ప్రధాన ( )
{
చార్ ch1 [ ] = { 'ఎల్' , 'నేను' , 'n' , 'లో' , 'x' } ;
int length = పరిమాణం ( ch1 ) / పరిమాణం ( ch1 [ 0 ] ) ;
printf ( 'మెమ్మోవ్() ఫంక్షన్ వర్తించే ముందు: ' ) ;
కోసం ( int i = 0 ; i < పొడవు; i++ )
{
printf ( '%c' , ch1 [ i ] ) ;
}
చార్ * ch2 = & ch1 [ రెండు ] ;
జ్ఞాపకముంచుకొనుము ( ch2, ch1, sizeof ( చార్ ) * రెండు ) ;
printf ( ' \n \n Memmove() ఫంక్షన్‌ని వర్తింపజేసిన తర్వాత: ' ) ;
కోసం ( int i = 0 ; i < 5 ; i++ )
{
printf ( '%c' , ch1 [ i ] ) ;
}
తిరిగి 0 ;
}
కంపైలర్‌ను ప్రారంభించిన తర్వాత మేము ఎల్లప్పుడూ కోర్ ప్రోగ్రామ్ మాడ్యూల్‌లను చేర్చడం ద్వారా ప్రారంభిస్తాము. ఈ మాడ్యూల్స్ బండిల్ చేయబడిన C లాంగ్వేజ్ మాడ్యూల్స్. మాడ్యూల్‌ను నిర్మించడానికి డజన్ల కొద్దీ కోడ్ లైన్‌లకు విరుద్ధంగా, ఈ మాడ్యూల్‌లను చేర్చడానికి మేము ఒక లైన్ కోడ్‌ని టైప్ చేయాలి. ప్రోగ్రామ్‌కు మాడ్యూల్‌ను జోడించడానికి “ఇన్‌క్లూడ్” కీవర్డ్‌ని ఉపయోగించే ముందు మాడ్యూల్‌ను లోడ్ చేయమని “#” సూచిక అనువాదకుడికి తెలియజేస్తుంది. “stdio.h” మాడ్యూల్ అంటే కంపైలర్ వినియోగదారు నుండి డేటాను అంగీకరిస్తుంది మరియు దానిని వినియోగదారుకు చూపుతుంది. ప్రోగ్రామ్ యొక్క రెండవ మాడ్యూల్ “#include
అప్పుడు, మేము మెయిన్() ఫంక్షన్‌ను ప్రారంభిస్తాము, తద్వారా ప్రోగ్రామ్‌లో అమలు చేయాలనుకుంటున్న కోడ్ యొక్క వాస్తవ పంక్తిని వ్రాయవచ్చు. లైన్ 6లో, మేము అక్షర శ్రేణి పేరు 'ch1' రకం అక్షరాన్ని ప్రకటిస్తాము. అప్పుడు, మేము దానికి అక్షర విలువను కేటాయిస్తాము. ఆ తర్వాత, మేము 'ch1' యొక్క పొడవును లెక్కిస్తాము మరియు 'ఫర్ లూప్' ఉపయోగించి ఇన్‌పుట్ అర్రే 'ch1'ని ప్రింట్ చేస్తాము.
ఆ తర్వాత, మేము పాయింటర్‌ను టైప్ క్యారెక్టర్ యొక్క “ch2” శ్రేణికి ప్రకటిస్తాము మరియు “ch1” అర్రే యొక్క చిరునామాను “ch2” శ్రేణికి కేటాయిస్తాము. అప్పుడు, మేము దానిని printf() స్టేట్‌మెంట్ ఉపయోగించి ప్రింట్ చేస్తాము. మునుపటి ఉదాహరణ యొక్క అవుట్‌పుట్‌ను చూద్దాం:
ఉదాహరణ 2: C++లో Memmove() ఫంక్షన్‌ని అమలు చేయడం
C++ భాషలో memmove() ఫంక్షన్ ఎలా పని చేస్తుందో చూపే ప్రాథమిక ఉదాహరణ ఇక్కడ ఉంది. రాయడం ప్రారంభించడానికి, మనకు ముందుగా C++ IDE అవసరం, తద్వారా మనం ప్రోగ్రామ్‌ని వ్రాసి అమలు చేయవచ్చు. దాని కోసం, C++ కంపైలర్‌ని తెరిచి, ప్రోగ్రామ్‌ను అమలు చేయడం ప్రారంభించండి.
కంపైలర్‌ను తెరిచిన తర్వాత, ప్రోగ్రామ్‌లు అమలు చేయడానికి C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌కు అవసరమైన హెడర్ ఫైల్‌లను చేర్చడం ద్వారా మేము ఎల్లప్పుడూ ప్రారంభిస్తాము. ప్రోగ్రామ్‌ను రూపొందించడానికి మరియు memmove() పద్ధతిని ఉపయోగించడానికి, మేము మొదట రెండు ప్రాథమిక హెడర్ ఫైల్‌లను చేర్చుతాము - “iostream” మరియు “cstring”. C++ శ్రేణులు మరియు స్ట్రింగ్‌లతో పనిచేయడానికి అనేక మార్గాలను అందిస్తుంది. మూలాధారం నుండి గమ్యస్థానానికి నిర్దిష్ట సంఖ్యలో బైట్‌ల డేటాను కాపీ చేయడానికి ఉపయోగించే “#include
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
చార్ src [ యాభై ] = '1234567890' ;
చార్ డెస్ట్ [ యాభై ] = '0987654321' ;
కోట్ << 'గమ్యస్థానానికి మెమోవ్ దరఖాస్తు చేయడానికి ముందు:' << ప్రారంభించండి << endl;
జ్ఞాపకముంచుకొనుము ( dest, src, 6 ) ;
కోట్ << 'గమ్యస్థానానికి మెమోవ్ దరఖాస్తు చేసిన తర్వాత:' << చేతులు
తిరిగి 0 ;
}
అసలు లైన్ కోడ్ అమలును ప్రారంభించడానికి మేము ప్రధాన() ఫంక్షన్‌ను వ్రాయడం ప్రారంభిస్తాము. లైన్ 7లో, పొడవు 50 యొక్క రెండు-అక్షరాల రకం శ్రేణి ఉంది, ఇది 'src[50]' మరియు 'dest[50]'గా ప్రకటించబడింది. మేము సందేశాన్ని ప్రింట్ చేయడానికి “కౌట్” స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము, “మెమ్మోవ్()ని గమ్యస్థానానికి వర్తింపజేయడానికి ముందు: ”. అప్పుడు, 'dest' శ్రేణి యొక్క విలువను ముద్రించడానికి మేము 'dest' పరామితిని పాస్ చేస్తాము. అప్పుడు, మూలం(src) నుండి లక్ష్యం(dest) వరకు నిర్దిష్ట సంఖ్యలో బైట్‌లను అతివ్యాప్తి చేయడానికి “src[50]” మరియు “dest[50]”గా ప్రకటించబడిన అక్షర రకం వేరియబుల్‌కు memmove() ఫంక్షన్ వర్తించబడుతుంది. 'గణన' సంఖ్య. ఇది “src” నుండి “dest”కి కాపీ చేయబడిన బైట్‌ల సంఖ్యను గుర్తిస్తుంది. మీరు క్రింది దృష్టాంతంలో చూడగలిగినట్లుగా, మేము '6' గణన సంఖ్యను ప్రకటించాము.
ఆ తర్వాత, “మెమ్మోవ్()ని గమ్యస్థానానికి వర్తింపజేసిన తర్వాత: ” అనే సందేశాన్ని ప్రదర్శించడానికి మేము మళ్లీ “కౌట్” స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము మరియు “క్యారెక్టర్” రకం యొక్క వేరియబుల్ “డెస్ట్” శ్రేణిని పాస్ చేస్తాము. ప్రోగ్రామ్ రన్ అవ్వకుండా ఆపడానికి, మేము ప్రోగ్రామ్ ముగింపులో తప్పనిసరిగా రిటర్న్ స్టేట్‌మెంట్‌ను ఉపయోగించాలి. మేము 0 ను ప్రధాన ఫంక్షన్‌కు తిరిగి ఇస్తాము, ప్రోగ్రామ్ విజయవంతంగా అమలు చేయబడిందని మరియు దాని లక్ష్యాన్ని సాధించిందని సూచిస్తుంది.
మీరు memmove() పద్ధతి యొక్క క్రింది అవుట్‌పుట్‌లో అతివ్యాప్తి ఉన్నట్లయితే, ఉదాహరణకు, ప్రారంభ పాయింటర్ 6 అక్షరానికి మారినప్పుడు, పాయింటర్ ముద్రణను ఉంచుతుంది మరియు క్రింది అక్షరాలు అతివ్యాప్తి చెందుతాయి. ఈ C++ కోడ్ స్నిప్పెట్ అమలు చేయబడింది మరియు ఫలితాలు క్రింది చిత్రంలో ప్రదర్శించబడతాయి:
ముగింపు
ఈ కథనంలో, మేము C మరియు C++ ప్రోగ్రామింగ్ భాషలలో మెమోవ్() ఫంక్షన్ గురించి తెలుసుకున్నాము. మేము C మరియు C++ యొక్క ఉదాహరణ ద్వారా memmove() ఫంక్షన్ ఎలా పనిచేస్తుందో, కోడ్ యొక్క ప్రతి లైన్ యొక్క వివరణాత్మక వివరణతో మాట్లాడాము. C మరియు C++లో మెమోవ్() ఫంక్షన్‌కు సంబంధించి మీ జ్ఞానాన్ని పెంపొందించడంలో ఈ కథనం మీకు సహాయకారిగా ఉంటుందని మేము ఆశిస్తున్నాము.