சி ++ இல், தாரையோட்ட(stream) இயக்கிகளான >> , << ஆகியவற்றுடன் I/O எனும் தாரை யோட்ட இனத்துடன் இணைத்து கோப்புகளைப் படித்திடுமாறும் எழுதிடுமாறும் செய்யலாம். கோப்புகளைப் படிக்கும்போது அல்லது எழுதும்போது, வன்தட்டில் ஒரு கோப்பைக் குறிக்கும் ஒரு இனத்தின் உதாரணத்திற்கு அந்த இயக்கிகள் பயன்படுத்தி கொள்ளப்படும். இந்த தாரை யோட்டத்தின்(stream) அடிப்படையிலான அணுகுமுறை ஒரு பெரிய நன்மையைக் கொண்டுள்ளது: ஒரு சி ++ கண்ணோட்டத்தில், நாம் எதைப் படிக்கின்றோம் அல்லது எழுதுகின்றோம் என்பது முக்கியமன்று, இது ஒரு கோப்பு, தரவுத்தளம், முகப்புத்திரை அல்லது இணைக்கப்பட்ட மற்றொரு கணினியுடனான. வலைப்பின்னல் ஆகும். எனவே, தாரையோட்ட இயக்கிகளைப் பயன்படுத்தி கோப்புகளை எவ்வாறு எழுதுவது என்று தெரிந்துகொள்வது கோப்புகளை பிற பகுதிகளுக்கு மாற்றப்படுவதை அறிந்து கொள்வதற்கு சமமாகும்.
I / O தாரையோட்ட இனங்கள்
சி ++ நிலையான நூலகம் ios_base இனத்தினை வழங்குகிறது. இந்த இனத்தின் basic_ofstream , basic_ifstream போன்ற அனைத்து I / O தாரையோட்ட-இணக்க இனங்களுக்கும் அடிப்படைஇனமாக செயல்படுகிறது. எடுத்துக்காட்டில், எழுத்துக்கள், ifstream ,ofstream ஆகியவற்றைப் படிக்க / எழுத சிறப்பு வகைகளைப் பயன்படுத்திகொள்ளப்படுகின்றது.
ofstream என்பது வெளியீட்டு file stream, என்ற பொருளாகும், மேலும் அதை செருகும் இயக்கிகளுடன் அணுகலாம்,
<<.
ifstream என்றால் உள்ளீட்டு file stream, என்று பொருளாகும் .மேலும் அதை பிரித்தெடுத்திடுகின்ற இயக்கிகளுடன் அணுகலாம்
>> .
இரண்டு வகைகளும் <fstream> எனும் தலைப்புக்குள் வரையறுக்கப்பட்டுள்ளன
IOS_base இலிருந்து பெறும் ஒருஇனமானது அதற்குள் எழுதும் போது ஒரு தரவு மூழ்கியாக அல்லது அதிலிருந்து படிக்கும்போது ஒரு தரவு மூலமாக கருதப்படலாம்,இவை தரவுகளி லிருந்து முற்றிலும் பிரிக்கப்பட்டிருக்கும். இந்த பொருள் சார்ந்த அணுகுமுறை தொடர்பு டையதைப் பிரித்தல் , சார்பு உட்செலுத்துதல் போன்ற கருத்தாக்கங்களை செயல்படுத்து வதை எளிதாக்குகிறது.
இது மிகவும் எளிதாக ஒரு தாரையோட்டத்தினைஉருவாக்குகிறது, அதற்காக ofstream என்பது எழுதுகிறது, ஒரு ifstream, என்பது உருவாக்குகிறது, பின்னர்அதிலிருந்து படிக்கிறது:
#include <iostream> // cout, cin, cerr etc…
#include <fstream> // ifstream, ofstream
#include <string>
int main()
{
std::string sFilename = “MyFile.txt”;
/******************************************
* *
* WRITING *
* *
******************************************/
std::ofstream fileSink(sFilename); // Creates an output file stream
if (!fileSink) {
std::cerr << “Canot open ” << sFilename << std::endl;
exit(-1);
}
/* std::endl will automatically append the correct EOL */
fileSink << “Hello Open Source World!” << std::endl;
/******************************************
* *
* READING *
* *
******************************************/
std::ifstream fileSource(sFilename); // Creates an input file stream
if (!fileSource) {
std::cerr << “Canot open ” << sFilename << std::endl;
exit(-1);
}
else {
// Intermediate buffer
std::string buffer;
// By default, the >> operator reads word by workd (till whitespace)
while (fileSource >> buffer)
{
std::cout << buffer << std::endl;
}
}
exit(0);
}
இந்த குறிமுறைவரிகள் கிட்ஹப்பில் கிடைக்கின்றன.நாம் அதை தொகுத்து செயல்படுத்தும் போது,அதற்கான வெளியீட்டைப் பெறமுடியும்: இது எளிய, நட்புடன்கூடிய துவக்க உதாரணமாகும். நம்முடைய சொந்த பயன்பாட்டில் இந்த குறிமுறைவரிகளைப் பயன் படுத்த விரும்பினால்,பின்வருவனவற்றை மனதில் கொள்க: நிரலாக்கத்தின் முடிவில் கோப்பு தாரையோட்டங்கள்( file streams) தானாக மூடப்பட்டுவிடும். நாம் அதனை தொடர்ந்து செயல்படுத்திட விரும்பினால், close() எனும் வழிமுறையை அழைப்பதன் மூலம் அவற்றை கைமுறையாக மூட வேண்டும். இந்த கோப்பு தாரையோட்ட (file stream ) இனங்கள் basic_ios, என்பதிலிருந்து (பல்வேறு நிலைகளுக்கு மேல்) பெறுகின்றன, இது அதிக பணிச் சுமையுடன் கூடிய இயக்கியாகும் (overloads the ! Operator ) நாம் தாரை யோட்டத்தினை அணுக முடியுமா என்பதை எளிமையாக சரிபார்த்துசெயல்படுத்தியபின்னர் இதுநம்மை அனுமதிக்கின்றது.
Cppreference.com இல், இந்த சரிபார்ப்பு எப்போது வெற்றிபெறும் (அல்லது வெற்றி பெறமுடியாது) என்பதற்கான ஒரு கண்ணோட்டத்தை காணலாம், மேலும் இதில் பிழைகளை கையாளுதலை செயல்படுத்தலாம். முன்னிருப்பாக, ifstream எனும் தாரையோட்டமானது காலிஇடத்தில் நின்று அதைத் தவிர்க்கிறது. நாம் EOF ஐ அடையும் வரை வரிவரியாக ஒவ்வொருவரியையும் படிக்க, getline (…) – எனும் வழி முறையைப் பயன்படுத்திகொள்க.
எண்ணிம (binary )கோப்புகளைப் படிப்பதற்கும் எழுதுவதற்கும், std :: ios :: எண்ணிம கொடியை கட்டமைப்பாளருக்கு அனுப்பிடுக: இது ஒவ்வொரு வரியிலும் EOL எழுத்துக்கள் சேர்க்கப்படுவதைத் தடுக்கிறது.
அமைப்புகளின் கண்ணோட்டத்தில் எழுதுதல்
கோப்புகளை எழுதும் போது, தரவுகள் கணினியின் நினைவக எழுதும் இடையகத்திற்கு எழுதப்படும். கணினியின் அழைப்புகளின் ஒத்திசைவை கணினி பெறும்போது, இந்த இடையகத்தின் உள்ளடக்கங்கள் வன்தட்டில் எழுதப்படும். கணினியிடம் சொல்லாமல் யூ.எஸ்.பி யை அகற்றக்கூடாது என்பதற்கான காரணமும் இந்த வழிமுறையாகும். வழக்கமாக, ஒத்திசைவானதுஒரு daemon. எனும் வழக்கமான அடிப்படையில் அழைக்கப் படுகிறது. நாம் உண்மையிலேயே பாதுகாப்பான பக்கத்தில் இருக்க விரும்பினால், நாம் ஒத்திசைவை கைமுறையாக அழைக்கலாம்:
#include <unistd.h> // needs to be included
sync();
சுருக்கமான முடிவுரை
சி ++ இல் உள்ள கோப்புகளைப் படிப்பதும் எழுதுவதும் அவ்வளவு சிக்கலானதன்று. மேலும், I / O எனும் தாரையோட்டங்களை (stream)எவ்வாறு கையாளுவது என நமக்குத் தெரிந்திருந்தால், எந்தவொரு I / O சாதனத்தையும் எவ்வாறு கையாளுவது என்பது நமக்குத் தெரிந்துவிடும் (கொள்கையளவில்). பல்வேறு வகையான I / O சாதனங்களுக்கான நூலகங்கள் எளிதாக அணுக தாரையோட்ட இயக்கிகளைப் பயன்படுத்த நம்மை அனுமதிக்கின்றன. இதனால்தான் I / O எனும் தாரையோட்டங்கள் எவ்வாறு செயல்படுகின்றன என்பதை அறிந்துகொள்வது நன்மை பயக்கும் என அறிவுறுத்தப்படுகின்றது.