நிரலாக்கத்தில் கோப்பு மேலாண்மை என்பது புரோகிராமர் சரளமாக இருக்க வேண்டிய ஒரு பணியாகும். பல்வேறு திறந்த, படிக்க மற்றும் எழுதும் செயல்பாடுகளைப் பற்றிய அறிவு அவசியம், ஏனெனில் கோப்புகளில் சேமிக்கப்படும் தகவல்களை சேமிக்க அல்லது அகற்றுவதற்கு அவை எப்போதும் தேவைப்படுகின்றன.
இந்த லினக்ஸ் குறிப்புக் கட்டுரையில், கோப்புகளை எழுத எழுத() செயல்பாட்டை எவ்வாறு பயன்படுத்துவது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள்.
இந்த எல்லா, அதன் தொடரியல், அழைப்பு முறை, உள்ளீடு மற்றும் வெளியீட்டு வாதங்கள், ஒவ்வொரு விஷயத்திலும் அது ஏற்றுக்கொள்ளும் தரவு வகை மற்றும் அதை எவ்வாறு சரியாக அறிவிப்பது என்பதைப் பற்றி அனைத்தையும் விளக்குவோம்.
பின்னர், இந்தச் செயல்பாட்டைப் பயன்படுத்துவதன் மூலம் நாங்கள் கற்றுக்கொண்டவற்றைப் பயன்படுத்துகிறோம், இது குறியீட்டுத் துணுக்குகள் மற்றும் படங்களுடன் உங்களுக்காகத் தயாரித்து, C மொழியில் எழுத() பயன்படுத்துவதைக் காட்டுகிறது.
நீங்கள் எழுதும்() செயல்பாட்டின் பயன்பாடு பற்றிய விரிவான அறிவைப் பெறுவதற்காக, இந்தச் செயல்பாட்டைப் பயன்படுத்தும் போது ஏற்படக்கூடிய தனிப்பட்ட பிழைகள் மற்றும் அவற்றைக் கண்டறிதல் மற்றும் அடையாளம் காண்பது ஆகியவற்றை விவரிக்கும் ஒரு சிறப்புப் பகுதியை நாங்கள் சேர்த்துள்ளோம். அவை ஏற்பட்டால் விரைவான தீர்வுக்கு தேவையான நுட்பங்கள்.
சி மொழியில் எழுது() செயல்பாட்டின் தொடரியல்
முழு எண்ணாக எழுது ( முழு எண்ணாக fd , வெற்றிடமானது * buf , அளவு_டி n ) ;C மொழியில் எழுது() செயல்பாட்டின் விளக்கம்
எழுது() செயல்பாடு திறந்த கோப்பில் எழுதுகிறது. 'fd' உள்ளீட்டு வாதத்தில் அதன் விளக்கத்தால் குறிப்பிடப்பட்ட கோப்பில் 'buf' மூலம் சுட்டிக்காட்டப்பட்ட இடையகத்தின் உள்ளடக்கங்களை இந்த செயல்பாடு எழுதுகிறது. கோப்பில் எழுதப்படும் தொகுதியின் அளவு “n” உள்ளீட்டு வாதத்தில் குறிப்பிடப்பட வேண்டும்.
எழுது() செயல்பாட்டின் மூலம் எழுத, கோப்பு திறந்த() செயல்பாட்டின் மூலம் திறக்கப்பட வேண்டும் மற்றும் O_RDONLY அல்லது O_RDWR பண்புக்கூறுகளில் குறிப்பிடப்பட வேண்டும். இல்லையெனில், இந்த செயல்பாடு எந்த விளைவையும் ஏற்படுத்தாது.
அழைப்பு வெற்றிகரமாக இருந்தால், அது உள்ளிடப்பட்ட எழுத்துக்களின் எண்ணிக்கையை வழங்குகிறது. எழுதும் போது பிழை ஏற்பட்டால், அது -1 க்கு சமமான முடிவை அளிக்கிறது. பிழையைக் குறிக்கும் அடையாளக் குறியீடு 'errno.h' தலைப்பில் வரையறுக்கப்பட்ட errno உலகளாவிய மாறியிலிருந்து மீட்டெடுக்கப்படலாம்.
பின்னர், இந்தச் செயல்பாட்டின் மிகவும் பொதுவான பிழைகளை எவ்வாறு கண்டறிவது மற்றும் அடையாளம் காண்பது என்பதை நாங்கள் விளக்கும் ஒரு பகுதியை நீங்கள் காண்பீர்கள்.
எழுது() செயல்பாடு 'unistd.h' தலைப்பில் வரையறுக்கப்பட்டுள்ளது. கோப்பைத் திறப்பதற்கான பண்புக்கூறுகள் மற்றும் பயன்முறையை வரையறுக்கும் கொடிகள் 'fcntl.h' இல் வரையறுக்கப்பட்டுள்ளன. திறந்த() மற்றும் எழுது() செயல்பாடுகளைப் பயன்படுத்த, இந்த தலைப்புகளை உங்கள் குறியீட்டில் பின்வருமாறு சேர்க்க வேண்டும்:
#உள்ளடக்க#
சி மொழியில் எழுது() செயல்பாட்டைப் பயன்படுத்தி ஒரு கோப்பில் எழுதுவது எப்படி
இந்த எடுத்துக்காட்டில், 'ஆவணங்கள்' கோப்பகத்தில் நாம் முன்பு உருவாக்கிய 'example.txt' என்ற வெற்று உரைக் கோப்பை எழுதுகிறோம்.
தேவையான தலைப்புகளைச் செருகுவது முதல் படி. பிரதான() செயல்பாட்டின் உள்ளே, திறந்த() செயல்பாட்டுடன் கோப்பைத் திறக்கவும். இதைச் செய்ய, கோப்பு விளக்கமாகச் செயல்படும் “fd” முழு எண்ணையும், கோப்பில் நாம் எழுத விரும்பும் உரையைக் கொண்ட 1024-எழுத்து “buf” இடையக வரிசையையும் அறிவிக்க வேண்டும். இந்த இடையகத்தில், 'example.txt' கோப்பில் எழுத GCC மேன் பக்கத்தின் முதல் பத்தியை சேமித்து வைக்கிறோம்.
வாசிப்பு/எழுது பயன்முறையில் திறந்த() செயல்பாட்டின் மூலம் கோப்பைத் திறந்த பிறகு, எழுது() செயல்பாட்டை அழைத்து, 'fd' கோப்பு விளக்கத்தை முதல் உள்ளீட்டு வாதமாகவும், 'buf' சுட்டிக்காட்டி இரண்டாவதாகவும் அனுப்புவதன் மூலம் கோப்பில் எழுதுகிறோம். வாதம், மற்றும் strlen() செயல்பாட்டின் மூலம் நாம் பெறும் மூன்றாவது வாதமாக வரிசையில் உள்ள சரத்தின் அளவு. இந்த உதாரணத்திற்கான குறியீடு இங்கே:
##
#உள்ளடக்க
#
#
#
#
வெற்றிடமானது முக்கிய ( )
{
முழு எண்ணாக fd ;
கரி தாங்கல் [ 1024 ] = 'நீங்கள் GCC ஐ அழைக்கும் போது, அது பொதுவாக முன் செயலாக்கம், தொகுத்தல், அசெம்பிளி மற்றும் இணைக்கும். ஒட்டுமொத்த விருப்பங்கள் இந்த செயல்முறையை ஒரு இடைநிலை கட்டத்தில் நிறுத்த அனுமதிக்கின்றன. எடுத்துக்காட்டாக, -c விருப்பம் இணைப்பியை இயக்க வேண்டாம் என்று கூறுகிறது. பின்னர் வெளியீடு கொண்டுள்ளது அசெம்பிளரால் ஆப்ஜெக்ட் கோப்புகள் வெளியீடு.' ;
fd = திறந்த ( 'Documents/example.txt' , O_RDWR ) ;
எழுது ( fd , & தாங்கல் , strlen ( தாங்கல் ) ) ;
நெருக்கமான ( fd ) ;
}
பின்வரும் படத்தில், எழுத்து() செயல்பாட்டால் எழுதப்பட்ட திறந்த கோப்புடன் இந்த குறியீட்டின் தொகுத்தல் மற்றும் செயல்படுத்தல் ஆகியவற்றைக் காண்கிறோம்:
C மொழியில் எழுது() செயல்பாடு மூலம் ஒரு கோப்பின் இறுதியில் உரையை எவ்வாறு சேர்ப்பது
O_WRONLY அல்லது O_RDWR கொடிகளைக் குறிப்பிட்டு ஒரு கோப்பைத் திறக்கும்போது, கர்சர் முதல் நிலைக்குத் தாவி அங்கிருந்து எழுதத் தொடங்குகிறது.
ஒரு கோப்பின் முடிவில் ஒரு உரையைச் சேர்க்க, அது O_WRONLY அல்லது O_RDWR கொடிகள் மற்றும் ஓபன்() செயல்பாட்டின் உள்ளீடு கொடிகள் வாதத்தில் உள்ள O_ APPEND கொடி ஆகியவற்றுக்கு இடையேயான தருக்க அல்லது செயல்பாட்டின் மூலம் கோப்பு திறக்கப்படும் போது குறிப்பிடப்பட வேண்டும். இந்த வழியில், கர்சர் கோப்பின் முடிவில் வைக்கப்பட்டு, அங்கிருந்து எழுதத் தொடங்குகிறது. மேலும், fcntl() செயல்பாட்டின் மூலம் கோப்பைத் திறந்தவுடன் பண்புக்கூறுகள் மற்றும் எழுதும் பயன்முறையை மாற்றலாம்.
பின்வரும் விளக்கப்படத்தில், முந்தைய எடுத்துக்காட்டில் நாங்கள் எழுதிய கோப்பின் முடிவில் உரையைச் சேர்க்கும் குறியீட்டைக் காணலாம்:
##
#உள்ளடக்க
#
#
#
#
வெற்றிடமானது முக்கிய ( )
{
முழு எண்ணாக fd ;
கரி தாங்கல் [ 1024 ] = 'இந்த உரை சேர்க்கப்பட்டது. இந்த உரை சேர்க்கப்பட்டது.' ;
fd = திறந்த ( 'Documents/example.txt' , O_RDWR | O_APPEND ) ;
எழுது ( fd , & தாங்கல் , strlen ( தாங்கல் ) ) ;
நெருக்கமான ( fd ) ;
}
பின்வரும் படம் சேர்க்கப்பட்ட உரையைக் காட்டுகிறது. நீங்கள் பார்க்க முடியும் என, இந்த திறப்பு முறை மூலம், எழுதும் () செயல்பாடு கோப்பில் எழுதப்பட்ட கடைசி எழுத்தின் நிலையில் எழுதத் தொடங்குகிறது:
C மொழியில் எழுதும்() செயல்பாட்டைப் பயன்படுத்தும் போது ஏற்படக்கூடிய பிழைகளைக் கண்டறிந்து அடையாளம் காண்பது எப்படி
எழுது() பயன்படுத்தி பல்வேறு பிழைகளை உருவாக்கலாம். இது நிகழும்போது, இந்தச் செயல்பாடு -1க்கு சமமான முடிவை வழங்குகிறது.
பிழை ஏற்பட்டுள்ளதா என்பதைத் தீர்மானிப்பதற்கான எளிதான வழி, 'if' நிபந்தனையைப் பயன்படுத்துவதாகும், அங்கு நிபந்தனையின் மதிப்பு -1 ஆகும். இப்போது, பிழை ஏற்பட்டுள்ளதா என்பதைத் தீர்மானிக்க இந்த முறையை எவ்வாறு பயன்படுத்தலாம் என்பதைப் பார்ப்போம்:
முழு எண்ணாக n ;n = எழுது ( fd , & தாங்கல் , strlen ( தாங்கல் ) ) ;
என்றால் ( n == - 1 ) {
printf ( 'கோப்பை எழுத முயற்சிக்கும்போது பிழை ஏற்பட்டது.' ) ;
}
எழுது() செயல்பாடு பிழையுடன் திரும்பினால், அது 'if' அறிக்கைக்கு மாறி, செய்தியை அச்சிடுகிறது, ' கோப்பை எழுத முயற்சிக்கும்போது பிழை ஏற்பட்டது '.
ஒரு பிழை ஏற்படும் போது, ஒரு எண் குறியீடு தானாகவே 'errno.h' தலைப்பில் வரையறுக்கப்பட்ட errno உலகளாவிய மாறியில் சேமிக்கப்படும். ஏற்பட்ட பிழையை அடையாளம் காண இந்த குறியீட்டைப் பயன்படுத்தலாம்.
பின்வரும் எழுத்து() செயல்பாடு உருவாக்கக்கூடிய பிழைகள் மற்றும் 'errno.h' தலைப்பில் வரையறுக்கப்பட்டிருக்கும், ஒவ்வொரு பிழையின் சுருக்கமான விளக்கம் மற்றும் அதனுடன் தொடர்புடைய முழு எண் மதிப்பு:
| வரையறை | பிழையில் மதிப்பு | பிழை |
|---|---|---|
| மீண்டும் | பதினொரு | மீண்டும் முயற்சி செய். |
| EBADF | 9 | தவறான கோப்பு எண். |
| EDESTADDRREQ | 89 | சேருமிட முகவரி தேவை. |
| EDQUOT | 122 | ஒதுக்கீட்டை மீறியது. |
| EFAULT | 14 | தவறான முகவரி. |
| EFBIG | 27 | கோப்பு மிகவும் பெரியது. |
| EINTR | 4 | சிஸ்டம் அழைப்பு தடைபட்டது. |
| சிங்கிள் சாய்ஸ் | 22 | தவறான வாதம். |
| EIO | 5 | I/O பிழை. |
| ENOSPC | 28 | சாதனத்தில் இடமில்லை. |
| மேல் | 1 | அறுவை சிகிச்சை அனுமதிக்கப்படவில்லை. |
பிழையைக் கண்டறிவதற்கான எளிதான வழி, எர்ர்னோ மாறி என்பது ஜம்ப் நிலை மற்றும் ஒவ்வொரு வழக்கும் பிழை வரையறையாக இருக்கும் சுவிட்சைத் திறப்பதாகும்.
அடுத்து, ஒரு விளக்கத்தை எதிர்மறை அடையாளத்துடன் உள்ளிட முயற்சிக்கும் ஒரு உதாரணத்தைப் பார்ப்போம், இதன் விளைவாக பிழை ஏற்படுகிறது. பிழையைக் கண்டறிய, முந்தைய துணுக்கில் பார்த்த “if” நிபந்தனையைப் பயன்படுத்துகிறோம். அதை அடையாளம் காண, இந்த செயல்பாடு உருவாக்கக்கூடிய மூன்று பொதுவான பிழைகள் கொண்ட சுவிட்சைத் திறக்கிறோம்.
##உள்ளடக்க
#
#
#
#
#
வெற்றிடமானது முக்கிய ( )
{
முழு எண்ணாக fd ;
முழு எண்ணாக n ;
கரி தாங்கல் [ 1024 ] = 'வணக்கம் உலகம்' ;
fd = திறந்த ( 'Documents/example.txt' , O_RDWR ) ;
n = எழுது ( - 2 , & தாங்கல் , strlen ( தாங்கல் ) ) ;
என்றால் ( n == - 1 ) {
சொடுக்கி ( தவறு ) {
வழக்கு EBADF : {
printf ( 'தவறான கோப்பு எண். பிழை: %i \n ' , தவறு ) ;
உடைக்க ; }
வழக்கு சிங்கிள் சாய்ஸ் : {
printf ( 'தவறான வாதம். பிழை: %i \n ' , தவறு ) ;
உடைக்க ; }
வழக்கு EIO : {
printf ( 'I/O பிழை . பிழை: %i \n ' , தவறு ) ;
உடைக்க ; }
}
}
}
பின்வரும் படத்தில் நாம் பார்ப்பது போல், தவறான விளக்கத்தை உள்ளீட்டு வாதமாக அனுப்பும்போது எழுது() செயல்பாடு பிழையை வழங்குகிறது. எர்னோ மாறியிலிருந்து பெறப்பட்ட மதிப்பு, ஜம்ப் நிபந்தனையாகப் பயன்படுத்தப்படுகிறது, இது நாம் EBADF வழக்கை உள்ளிடும்போது பிழையைக் கண்டறிய அனுமதிக்கிறது.
முடிவுரை
இந்த லினக்ஸ் குறிப்புக் கட்டுரையில், கோப்புகளை எழுத எழுத() செயல்பாட்டை எவ்வாறு பயன்படுத்துவது என்பதை நாங்கள் உங்களுக்குக் காண்பித்தோம். இந்தச் செயல்பாட்டின் தொடரியல் மற்றும் தத்துவார்த்த விளக்கத்தை நாங்கள் உங்களுக்குக் காண்பித்தோம். பிழை கண்டறிதல் மற்றும் அடையாளம் காணும் முறைகளையும் நாங்கள் விளக்கியுள்ளோம், எனவே இந்த சிக்கல்களை விரைவாக தீர்க்க தேவையான கருவிகள் மற்றும் நுட்பங்கள் உங்களிடம் உள்ளன.
எழுதுதல்() எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்பதற்கு உங்களுக்கு உதவ, இந்தச் செயல்பாட்டின் பயன்பாட்டை நடைமுறை எடுத்துக்காட்டுகளில் குறியீடுகள் மற்றும் படங்களுடன் செயல்படுத்தியுள்ளோம், இது மற்றும் பிற கோப்பு செயலாக்க செயல்பாடுகளின் பயன்பாட்டைக் காட்டுகிறது.
கோப்பின் தொடக்கத்திலோ அல்லது முடிவிலோ உரையைச் செருக, கோப்பு திறந்த பயன்முறையை எவ்வாறு தேர்ந்தெடுப்பது என்பதையும், இந்த பண்புகளை மாற்றுவதற்கு என்ன செயல்பாடுகள் உள்ளன என்பதையும் நாங்கள் உங்களுக்குக் காண்பித்தோம்.