தொடரியல்:
கரி* strcpy (கரி*இலக்கு இடம், கான்ஸ்ட் கரி*ஆதாரம்_சரம்);Strcpy () புரிந்து கொள்ளுதல்:
Strcpy () செயல்பாட்டின் ஒரே நோக்கம் ஒரு சரத்தை மூலத்திலிருந்து இலக்குக்கு நகலெடுப்பதுதான். இப்போது, மேலே உள்ள strcpy () செயல்பாட்டின் தொடரியலைப் பார்ப்போம். Strcpy () செயல்பாடு இரண்டு அளவுருக்களை ஏற்கும் திறன் கொண்டது -
- கரி * இலக்கு
- const char * ஆதாரம்
Strcpy () செயல்பாடு மூல சரத்தை மாற்ற முடியாது என்பதை உறுதி செய்ய ஆதாரம் இங்கே ஒரு மாறிலி. Strcpy () செயல்பாடு அனைத்து எழுத்துக்களையும் (சரத்தின் முடிவில் உள்ள NULL எழுத்து உட்பட) மூல சரத்திலிருந்து இலக்குக்கு நகலெடுக்கிறது. மூலத்திலிருந்து இலக்குக்கு நகல் செயல்பாடு முடிந்தவுடன், strcpy () செயல்பாடு இலக்கின் முகவரியை மீண்டும் அழைப்பாளர் செயல்பாட்டிற்குத் தருகிறது.
இங்கு கவனிக்க வேண்டிய முக்கியமான விஷயம் என்னவென்றால், strcpy () செயல்பாடு மூல சரத்தை இலக்கு சரத்துடன் இணைக்காது. இது மூல சரத்தின் உள்ளடக்கத்துடன் இலக்கு உள்ளடக்கத்தை மாற்றுகிறது.
மேலும், strcpy () செயல்பாடு இலக்கு அளவு மூல சரத்தை விட அதிகமாக இருப்பதை உறுதி செய்ய எந்த சோதனையையும் செய்யாது, அது முற்றிலும் புரோகிராமரின் பொறுப்பாகும்.
உதாரணங்கள்:
இப்போது, strcpy () செயல்பாட்டைப் புரிந்துகொள்ள பல எடுத்துக்காட்டுகளைக் காண்போம்:
- strcpy () - இயல்பான செயல்பாடு (உதாரணம் 1. சி)
- strcpy ()-வழக்கு -1 (உதாரணம் 2. சி)
- strcpy ()-வழக்கு -2 (உதாரணம் 3. சி)
- strcpy ()-வழக்கு -3 (உதாரணம் 4. சி)
- strcpy () - பயனர் வரையறுக்கப்பட்ட பதிப்பு (உதாரணம் 5. சி)
- strcpy () - பயனர் வரையறுக்கப்பட்ட பதிப்பு உகந்ததாக (உதாரணம் 6. சி)
strcpy () - இயல்பான செயல்பாடு (உதாரணம் 1. சி):
சி நிரலாக்க மொழியில் strcpy () செயல்பாட்டைப் பயன்படுத்தி ஒரு சாதாரண சரம் நகல் செயல்பாட்டை எவ்வாறு செய்வது என்பதை இந்த எடுத்துக்காட்டு நிரல் காட்டுகிறது. இலக்கு சரத்தின் நீளம் 30 (char destination_str [30];) என்பதை கவனத்தில் கொள்ளவும், இது மூல சரத்தின் நீளத்தை விட அதிகமாக உள்ளது (நீளம் 18 ஆனது NULL எழுத்து உட்பட) இதனால் இலக்கு அனைத்து எழுத்துக்களுக்கும் இடமளிக்கும் மூல சரம்.
#சேர்க்கிறது
#சேர்க்கிறது
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 (உதாரணம் 2. சி):
இந்த எடுத்துக்காட்டு திட்டத்தின் நோக்கம், ஆதார சரத்தின் நீளத்தை விட இலக்கு சரத்தின் நீளம் குறைவாக இருக்கும்போது என்ன நடக்கிறது என்பதை தெளிவாக விளக்குவதாகும். இதுபோன்ற சந்தர்ப்பங்களில், இலக்கு இருப்பிடத்தில் மூல எழுத்துக்களில் இருந்து அனைத்து எழுத்துக்களையும் (முழு எழுத்து உட்பட) இடமளிக்க போதுமான இடைவெளிகள்/பைட்டுகள் இருக்காது. இரண்டு விஷயங்களை, நீங்கள் எப்போதும் மனதில் கொள்ள வேண்டும்:
- இலக்குக்கு போதுமான இடம் இருக்கிறதா என்று strcpy () செயல்பாடு சரிபார்க்காது.
- உட்பொதிக்கப்பட்ட மென்பொருளில் இது ஆபத்தானதாக இருக்கலாம், ஏனெனில் strcpy () இலக்கு எல்லைக்கு அப்பால் நினைவக பகுதியை மாற்றும்.
உதாரணத் திட்டத்தைப் பார்ப்போம். நாங்கள் source_str ஐ அறிவித்து அதை துவக்கியுள்ளோம் www.linuxhint.com , ஸ்ட்ரிங்கின் முடிவில் உள்ள Null கேரக்டர் உட்பட, 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. சி):
இலக்கு சரத்தின் அளவு மூல சரம் அளவை விட அதிகமாக இருக்கும் போது இந்த திட்டம் நிரலை விளக்குகிறது மற்றும் இலக்கு சரம் ஏற்கனவே சில மதிப்புடன் துவக்கப்பட்டுள்ளது. இந்த எடுத்துக்காட்டில், நாங்கள் துவக்கியுள்ளோம்:
- ஆதாரம்_எஸ்டிஆர் www.linuxhint.com [அளவு = 17+1 = 18]
- I_AM_A_DESTINATION_STRING க்கு இலக்கு_ஸ்ட்ர் [size = 25+1 = 26]
Strcpy () செயல்பாடு அனைத்து 17 எழுத்துகளையும் மற்றும் NULL எழுத்தையும் மூல சரத்திலிருந்து இலக்கு சரத்திற்கு நகலெடுக்கும். ஆனால், இலக்கு வரிசையில் மீதமுள்ள பைட்டுகளை (பைட் 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இலக்கு சரம் = ');
க்கான(intநான்=0;நான்<25;நான்++)
{
printf ('% c',இலக்கு_எஸ்டிஆர்[நான்]);
}
printf (' n n');
திரும்ப 0;
}
strcpy ()-வழக்கு -3 (உதாரணம் 4.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 () - பயனர் வரையறுக்கப்பட்ட பதிப்பு (உதாரணம் 5. சி):
இந்த எடுத்துக்காட்டு நிரலில், strcpy () செயல்பாட்டின் பயனர் வரையறுக்கப்பட்ட பதிப்பை எப்படி எழுதுவது என்பதை நாங்கள் காட்டியுள்ளோம்.
#சேர்க்கிறதுகரி *strcpy_user_defined(கரி *விதி, கான்ஸ்ட் கரி *src);
/ * Strcpy () செயல்பாட்டின் பயனர் வரையறுக்கப்பட்ட பதிப்பு */
கரி *strcpy_user_defined(கரி *விதி, கான்ஸ்ட் கரி *src)
{
கரி *டெஸ்ட்_பேக்அப்=விதி;
போது(*src! = ' 0') /* ' 0' கண்டுபிடிக்கப்படும் வரை மீண்டும் செய்யவும்.*/
{
*விதி= *src; / * மூலக் கரியை இலக்குக்கு நகலெடுக்கவும் */
src++; / * அதிகரிப்பு மூல சுட்டிக்காட்டி */
விதி++; / * அதிகரிப்பு இலக்கு சுட்டிக்காட்டி */
}
*விதி= ' 0'; /* இலக்கில் ' 0' ஐ வெளிப்படையாகச் செருகவும்*/
திரும்படெஸ்ட்_பேக்அப்;
}
intமுக்கிய()
{
கரிsource_str[] = 'www.linuxhint.com';
கரிஇலக்கு_எஸ்டிஆர்[30];
printf (பயனரை வரையறுக்கும் சரம் நகல் செயல்பாட்டை அழைப்பதற்கு முன்: n n');
printf (' tமூல சரம் = %s n',source_str);
printf (' tஇலக்கு சரம் = %s n n',இலக்கு_எஸ்டிஆர்);
/ * பயனரை வரையறுக்கப்பட்ட சரம் நகல் செயல்பாடு */
strcpy_user_defined(இலக்கு_எஸ்டிஆர்,source_str);
printf (பயனர் வரையறுக்கப்பட்ட சரம் நகல் செயல்பாட்டைச் செய்த பிறகு: n n');
printf (' tமூல சரம் = %s n',source_str);
printf (' tஇலக்கு சரம் = %s n n',இலக்கு_எஸ்டிஆர்);
திரும்ப 0;
}
strcpy () - பயனர் வரையறுக்கப்பட்ட பதிப்பு உகந்ததாக (உதாரணம் 6. சி):
இப்போது, இந்த எடுத்துக்காட்டு திட்டத்தில், நாங்கள் strcpy () இன் பயனர் வரையறுக்கப்பட்ட பதிப்பை மேம்படுத்த போகிறோம்.
#சேர்க்கிறதுகரி *strcpy_user_defined(கரி *விதி, கான்ஸ்ட் கரி *src);
/ * பயனர் வரையறுக்கப்பட்ட strcpy () செயல்பாட்டின் உகந்த பதிப்பு */
கரி *strcpy_user_defined(கரி *விதி, கான்ஸ்ட் கரி *src)
{
கரி *டெஸ்ட்_பேக்அப்=விதி;
போது(*விதி++ = *src++)
;
திரும்படெஸ்ட்_பேக்அப்;
}
intமுக்கிய()
{
கரிsource_str[] = 'www.linuxhint.com';
கரிஇலக்கு_எஸ்டிஆர்[30];
printf (பயனரை வரையறுக்கும் சரம் நகல் செயல்பாட்டை அழைப்பதற்கு முன்: n n');
printf (' tமூல சரம் = %s n',source_str);
printf (' tஇலக்கு சரம் = %s n n',இலக்கு_எஸ்டிஆர்);
/ * பயனரை வரையறுக்கப்பட்ட சரம் நகல் செயல்பாடு */
strcpy_user_defined(இலக்கு_எஸ்டிஆர்,source_str);
printf (பயனர் வரையறுக்கப்பட்ட சரம் நகல் செயல்பாட்டைச் செய்த பிறகு: n n');
printf (' tமூல சரம் = %s n',source_str);
printf (' tஇலக்கு சரம் = %s n n',இலக்கு_எஸ்டிஆர்);
திரும்ப 0;
}
முடிவுரை :
சி நிரலாக்க மொழியில் சரம் நகல் செயல்பாட்டைச் செய்ய strcpy () செயல்பாடு மிகவும் பிரபலமான மற்றும் எளிமையான நூலகச் செயல்பாடாகும். இது முக்கியமாக ஒரு இடத்தில் இருந்து மற்றொரு இடத்திற்கு சரத்தை நகலெடுக்கப் பயன்படுகிறது. எவ்வாறாயினும், strcpy () செயல்பாடு இலக்கு வரிசையின் எல்லை சரிபார்ப்பைச் செய்யாது என்ற உண்மையை நாங்கள் மீண்டும் வலியுறுத்த விரும்புகிறோம், இது புறக்கணிக்கப்பட்டால் ஒரு தீவிர மென்பொருள் பிழைக்கு வழிவகுக்கும். இலக்கு வரிசையில் NULL எழுத்து உட்பட அனைத்து எழுத்துக்களையும் பிடிப்பதற்கு போதுமான இடம் இருப்பதை உறுதி செய்வது நிரலாளரின் பொறுப்பாகும்.