გახსენით ფაილი პროგრამიდან c. ფაილის გახსნა. ჩართვისა და ექსტრაქციის ოპერატორები

ნაკადი დახურულია ოპერატორის გამოყენებით:

ვ.close();

მაგალითად, განიხილეთ შემდეგი პრობლემა.

დავალება 1

შექმენით ტექსტური ფაილი დ:\\ საიტები\\ანგარიშები .ტექსტიდა ჩაწერეთ მასში ნრეალური რიცხვები.

გამოსავალი

ინფორმაციის წაკითხვა ტექსტური ფაილიდან

ტექსტური ფაილიდან ინფორმაციის წასაკითხად აუცილებელია ტიპის ცვლადის გამოცხადება ifstream. ამის შემდეგ, თქვენ უნდა გახსნათ ფაილი ოპერატორის გამოყენებით წასაკითხად გახსნა. თუ ცვლადი დასახელებულია ფ, მაშინ პირველი ორი განცხადება იქნება:

ფაილის წაკითხვის რეჟიმში გახსნის შემდეგ, შეგიძლიათ მისგან ინფორმაციის წაკითხვა ისევე, როგორც კლავიატურიდან, მხოლოდ ამის ნაცვლად ცინთქვენ უნდა მიუთითოთ ნაკადის სახელი, საიდანაც წაიკითხება მონაცემები.

მაგალითად, ნაკადიდან მონაცემების წასაკითხად ფცვლადში ა, შეყვანის განცხადება ასე გამოიყურება:

F>>a;

ტექსტის რედაქტორში ორი რიცხვი განცალკევებულად ითვლება, თუ მათ შორის არის მინიმუმ ერთი სიმბოლო: ინტერვალი, ჩანართი, ხაზის ბოლოს სიმბოლო. კარგია, როცა პროგრამისტმა წინასწარ იცის, რამდენი და რა მნიშვნელობა ინახება ტექსტურ ფაილში. თუმცა, ხშირად ცნობილია მხოლოდ ფაილში შენახული მნიშვნელობების ტიპი და მათი რაოდენობა შეიძლება განსხვავდებოდეს. ამ პრობლემის გადასაჭრელად აუცილებელია ფაილიდან მნიშვნელობების სათითაოდ წაკითხვა და ყოველი წაკითხვის წინ შეამოწმეთ მიღწეულია თუ არა ფაილის დასასრული. და ფუნქცია დაგეხმარებათ ამის გაკეთებაში f.eof(). Აქ ფ- ძაფის სახელის ფუნქცია აბრუნებს ლოგიკურ მნიშვნელობას: მართალიაან ყალბი, იმის მიხედვით, მიღწეულია თუ არა ფაილის ბოლომდე.

ამრიგად, მთელი ფაილის შინაარსის წაკითხვის ციკლი შეიძლება დაიწეროს ასე:

მასალის უკეთესი ასიმილაციისთვის განიხილეთ პრობლემა.

დავალება 2

რეალური ნომრები ინახება ტექსტურ ფაილში D:\\game\\accounts.txt, აჩვენეთ ისინი ეკრანზე და გამოთვალეთ მათი რაოდენობა.

გამოსავალი

ამით დასრულდა შედარებით მოცულობითი გაკვეთილი ტექსტურ ფაილებზე. შემდეგი სტატია განიხილავს მანიპულირების მეთოდებს, რომლებსაც C++ იყენებს.

I/O-ს მიერ შემუშავებული მექანიზმი არ შეესაბამება დღეს ობიექტზე ორიენტირებული პროგრამირების ზოგადად მიღებულ სტილს, გარდა ამისა, იგი აქტიურად იყენებს მაჩვენებლის ოპერაციებს, რომლებიც პოტენციურად სახიფათოა თანამედროვე უსაფრთხო კოდის შესრულების გარემოში. აპლიკაციის განვითარების ალტერნატივა არის სტანდარტული I/O კლასის მექანიზმი, რომელიც გათვალისწინებულია C++ ენის სტანდარტით.

ფაილების გახსნა

ყველაზე ხშირად გამოყენებული კლასები არის ifstream კითხვისთვის, ofstream წერისთვის და fstream ფაილების შესაცვლელად.

ყველა ხრახნიანი I/O კლასი ირიბად მიღებულია საერთო წინაპარი ios-დან, სრულად მემკვიდრეობით მის ფუნქციონირებას. მაგალითად, open_mode enumerated data წევრი განსაზღვრავს ფაილის ღია რეჟიმს, რომელიც განისაზღვრება შემდეგნაირად:

Enum open_mode (აპი, ორობითი, in, out, trunc, ate);

ქვემოთ მოცემულია დროშების შესაძლო მნიშვნელობები და მათი დანიშნულება.

მაგალითად, ფაილის სახელწოდებით test.txt გასახსნელად ბინარული მონაცემების წასაკითხად, თქვენ დაწერთ:

ifstream ფაილი; file.open("test.txt", ios::in | ios::ბინარული);

ლოგიკური OR ოპერატორი (|) საშუალებას გაძლევთ შეადგინოთ რეჟიმი დროშების ნებისმიერი კომბინაციით. იმისათვის, რომ ფაილის წერით გახსნისას, შემთხვევით არ გადაიწეროთ არსებული ფაილი იგივე სახელით, უნდა გამოიყენოთ შემდეგი ფორმა:

offstream ფაილი; file.open("test.txt", ios::out | ios::app);

ვარაუდობენ, რომ შესაბამისი სათაურის ფაილი დაკავშირებულია პროექტთან:

#შეიცავს

იმის შესამოწმებლად, თუ ფაილი წარმატებით გაიხსნა, შეგიძლიათ გამოიყენოთ კონსტრუქცია

თუ (! ფაილი) ( // ფაილის გახსნის შეცდომის დამუშავება )

ჩართვისა და ექსტრაქციის ოპერატორები

გადარიცხულია ფაილების დამუშავების კლასებში მოიცავს ოპერატორს (<<) записывает данные в файловый поток. Как только вы открыли файл для записи, можно записывать в него текстовую строку целиком:

ფაილი<< "Это строка текста";

თქვენ ასევე შეგიძლიათ დაწეროთ ტექსტის სტრიქონი ნაწილებად:

ფაილი<< "Это " << "строка " << "текста";

endl განცხადება ამთავრებს ხაზის შეყვანას კარის დაბრუნებით:

ფაილი<< "Это строка текста" << endl;

ჩათვლით ოპერატორის გამოყენებით, ადვილია ფაილში ცვლადების ან მასივის ელემენტების მნიშვნელობების ჩაწერა:

Offstream ფაილი ("Temp.txt"); char buff = "ტექსტური მასივი შეიცავს ცვლადებს"; int vx = 100; float pi = 3.14159; ფაილი<< buff << endl << vx << endl << pi << endl;

კოდის შესრულების შედეგად წარმოიქმნება Temp.txt ტექსტური ფაილის სამი ხაზი:

ტექსტური მასივი შეიცავს ცვლადებს 100 3.14159

გაითვალისწინეთ, რომ რიცხვითი მნიშვნელობები იწერება ფაილში ტექსტის სტრიქონების სახით და არა ორობითი მნიშვნელობებით.

ამოღების ოპერატორი(>>) აკეთებს პირიქით. როგორც ჩანს, ადრე დაწერილი Temp.txt ფაილიდან სიმბოლოების ამოსაღებად, თქვენ უნდა დაწეროთ შემდეგი კოდი:

ifstream ფაილი ("Temp.txt"); char buff; intvx; floatpi; ფაილი >> buff >> vx >> pi;

თუმცა, ამოღების ოპერატორი გაჩერდება პირველ დელიმიტერზე (სივრცე, ჩანართი ან ახალი ხაზი), რომელსაც ის შეხვდება. ამრიგად, წინადადების „ტექსტური მასივი შეიცავს ცვლადებს“ ანალიზისას, მხოლოდ სიტყვა „ტექსტი“ ჩაიწერება მასივის ბუფში, სივრცე იგნორირებული იქნება და სიტყვა „მასივი“ გახდება მთელი რიცხვი ცვლადის vx და კოდი. აღსრულება "გააფუჭებს" მონაცემთა სტრუქტურის გარდაუვალი დარღვევით. შემდეგ, ifstream კლასზე განხილვისას, ჩვენ ვაჩვენებთ, თუ როგორ სწორად მოაწყოთ ფაილის წაკითხვა წინა მაგალითიდან.

ifstream კლასი: ფაილების კითხვა

როგორც სახელი გულისხმობს, ifstream კლასი შექმნილია ფაილის ნაკადის შესაყვანად. კლასის ძირითადი მეთოდები ჩამოთვლილია ქვემოთ. მათი უმეტესობა მემკვიდრეობით მიიღება istream კლასიდან და გადატვირთულია მშობლის ფუნქციებით. მაგალითად, get ფუნქციას, ზარის პარამეტრიდან გამომდინარე, შეუძლია წაიკითხოს არა მხოლოდ ერთი სიმბოლო, არამედ სიმბოლოების ბლოკიც.

ახლა გასაგებია, თუ როგორ უნდა შეცვალოთ წინა მაგალითი ისე, რომ მონაცემთა ამოღების ოპერატორის გამოყენებით მივიღოთ მოსალოდნელი შედეგი:

ifstream ფაილი ("Temp.txt"); char buff; intvx; floatpi; file.getline(buff, sizeof(buff)); ფაილი >> vx >> pi:

getline მეთოდი ბოლომდე წაიკითხავს ფაილის პირველ სტრიქონს და >> ოპერატორი მიანიჭებს მნიშვნელობებს ცვლადებს.

შემდეგი მაგალითი გვიჩვენებს ტექსტურ ფაილში მონაცემების დამატებას და შემდეგ მთელი ფაილის წაკითხვას. while (1) მარყუჟი გამოიყენება while(!file2.eof())-ის ნაცვლად ში განხილული მიზეზების გამო.

#შეიცავს #შეიცავს namespace std-ის გამოყენებით; int main() ( ნაკადის ფაილი; file.open ("test.txt",ios::out|ios::app); if (!ფაილი) (cout<< "File error - can"t open to write data!"; cin.sync(); cin.get(); return 1; } for (int i=0; i<10; i++) file << i << endl; file.close(); ifstream file2; file2.open("test.txt", ios::in); if (!file2) { cout << "File error - can"t open to read data!"; cin.sync(); cin.get(); return 2; } int a,k=0; while (1) { file2 >>ა; if (file2.eof()) break; კოუტ<< a << " "; k++; } cout << endl << "K=" << k << endl; file2.close(); cin.sync(); cin.get(); return 0; }

შემდეგი მაგალითი კითხულობს ხაზებს ფაილის test.txt-დან და აჩვენებს მათ კონსოლზე.

#შეიცავს #შეიცავს namespace std-ის გამოყენებით; int main() ( ifstream ფაილი; // შექმენით ნაკადის ობიექტი ფაილი file.open("test.txt"); // გახსენით ფაილი წასაკითხად, თუ (!file) დააბრუნებს 1; // შეცდომის დაბრუნებას char str;/ / სტატიკური ხაზის ბუფერი // წაიკითხეთ და აჩვენეთ ხაზები მარყუჟში eof-მდე, ხოლო (!file.getline(str, sizeof(str)).eof()) cout<< str << endl; // вывод прочитанной строки на экран cin.sync(); cin.get(); return 0; }

ეს კოდი Windows OS-ში ასევე დამოკიდებულია ფაილის ბოლო სტრიქონში ახალი ხაზის სიმბოლოს არსებობაზე, უფრო საიმედო იქნება ამის გაკეთება:

while (1) ( if (file.eof()) break; file.getline(str, sizeof(str)); cout<< str << endl; }

ღია და დახურვის მეთოდებზე აშკარა ზარები არჩევითია. მართლაც, კონსტრუქტორის არგუმენტით გამოძახება საშუალებას გაძლევთ დაუყოვნებლივ გახსნათ ფაილი, ფაილის ნაკადის ობიექტის შექმნის მომენტში:

ifstream ფაილი ("test.txt");

დახურვის მეთოდის ნაცვლად შეგიძლიათ გამოიყენოთ delete ოპერატორი, რომელიც ავტომატურად გამოიძახებს ფაილის ობიექტის დესტრუქტორს და დახურავს ფაილს. while მარყუჟის კოდი უზრუნველყოფს ფაილის ბოლოს სათანადო შემოწმებას.

ofstream class: ფაილების წერა

ofstream კლასი შექმნილია ფაილის ნაკადიდან მონაცემების გამოსატანად. ამ კლასის ძირითადი მეთოდები ჩამოთვლილია ქვემოთ.

ზემოთ აღწერილი ჩათვლით ოპერატორი მოსახერხებელია ტექსტურ ფაილზე ჩაწერის ორგანიზებისთვის:

Offstream ფაილი ("temp.txt"); თუ (!ფაილი) დაბრუნდება; for (int i=1; i<=3; i++) file << "Строка " << i << endl; file.close();

ორობითი

პრინციპში, ორობითი მონაცემები ემსახურება ტექსტის მონაცემებს. განსხვავება ისაა, რომ თუ ორობითი მონაცემები იწერება გარკვეულ ლოგიკურ სტრუქტურაში, მაშინ ისინი უნდა წაიკითხონ ფაილიდან იმავე სტრუქტურის ტიპის ცვლადში.

ჩაწერისა და წაკითხვის მეთოდების პირველი პარამეტრი (ჩაწერის/წაკითხვის ბლოკის მისამართი) უნდა იყოს სიმბოლოს მაჩვენებლის ტიპი char *, ამიტომ აუცილებელია ცალსახად გადაიყვანოთ void * სტრუქტურის მისამართის ტიპი. მეორე პარამეტრი მიუთითებს, რომ ფაილის ორობით ბლოკებს აქვთ ბაიტის მუდმივი ზომა, მიუხედავად ჩანაწერის რეალური სიგრძისა. შემდეგი დანართში მოცემულია მაგალითი იმისა, თუ როგორ უნდა შექმნათ და აჩვენოთ მონაცემები მარტივ ნოუთბუქში. შემდეგ ფაილის ჩანაწერები იკითხება თანმიმდევრულად და გამოჩნდება კონსოლზე.

#შეიცავს #შეიცავს #შეიცავს namespace std-ის გამოყენებით; struct Notes ( // ნოუთბუქის მონაცემთა სტრუქტურა char სახელი; // სრული სახელი char ტელეფონი; // phone int ასაკი; // ასაკი ); int main() ( setlocale (LC_ALL, "რუსული"); შენიშვნები Note1= ("გროზნი იოანე ვასილიევიჩი", "არ არის დაინსტალირებული", 60); შენიშვნები Note2= ("გოდუნოვი ბორის ფედოროვიჩი", "095-111-2233", 30); შენიშვნები შენიშვნა3= ("პეტერ რომანოვი", "812-333-2211", 20); ofile ნაკადის ("Notebook.dat", ios::binary); ofile.write ((char*)&Note1, sizeof ( შენიშვნები)); // 1-ლი ბლოკი ofile.write((char*)&Note2, sizeof(Notes)); // მე-2 ბლოკი ofile.write((char*)&Note3, sizeof(Notes)); // მე-3 ბლოკი ofile. close(); // დახურეთ დაწერილი ფაილი ifstream ifile ("Notebook.dat", ios::binary); შენიშვნები შენიშვნა; // სტრუქტურირებული ცვლადი char str; // სტატიკური სტრიქონის ბუფერი // წაიკითხეთ და აჩვენეთ ხაზები მარყუჟში, სანამ eof while (!ifile.read((char*)&Note, sizeof(Notes)).eof()) ( sprintf(str, "%s\tBody: %s\tAge: %d" , Note.Name, Note. ტელეფონი, შენიშვნა. ასაკი); cout<< str << endl; } ifile.close(); // закрыть прочитанный файл cin.sync(); cin.get(); return 0; }

ამ კოდის შესრულების შედეგად, ორობითი ფაილი Notebook.dat იქმნება სამი ბლოკისგან 80 ბაიტი თითოეული (დავარაუდეთ, რომ სიმბოლოები ერთბაიტიანია). ბუნებრივია, შეგიძლიათ გამოიყენოთ ნაკადის სხვა მეთოდები და შეასრულოთ ნებისმიერი ოპერაცია კონკრეტული მონაცემთა სტრუქტურის ველებზე.

fstream კლასი: ფაილების შემთხვევითი წვდომა

დავუშვათ, რომ ჩვენმა ბლოკნოტმა დააგროვა 100 ჩანაწერი და ჩვენ გვინდა დავთვალოთ 50-ე. რა თქმა უნდა, შეგიძლიათ მოაწყოთ ციკლი და წაიკითხოთ ყველა ჩანაწერი პირველიდან მოცემულამდე. ცხადია, უფრო მიზანმიმართული გამოსავალი არის pos ფაილის პოზიციის მაჩვენებლის დაყენება პირდაპირ 50-ზე და მისი წაკითხვა:

ifstream ifile ("Notebook.dat", ios::binary); int pos = 49 * sizeof(Notes); ifile seek(pos); // 50-ე ჩანაწერის ძიება შენიშვნები შენიშვნა; //Notes - ზემოთ აღწერილი "ჩანაწერის" სტრუქტურა ifile.read((char*)&Note, sizeof(Notes));

ასეთი საძიებო ოპერაციები ეფექტურია, თუ ფაილი შედგება ცნობილი და მუდმივი ზომის ჩანაწერებისგან. თვითნებური ჩანაწერის შინაარსის შესაცვლელად, თქვენ უნდა გახსნათ გამომავალი ნაკადი მოდიფიცირების რეჟიმში:

Ofstream ofile("Notebook.dat", ios::binary | ios::ate); int pos = 49 * sizeof(Notes); ofile seekp(pos); // მოძებნეთ 50-ე შენიშვნა შენიშვნები Note50 = ("ელცინ ბორის ნიკოლაევიჩი", "095-222-3322", 64); ofile.write((char*)&Note, sizeof(Notes)); // ჩანაცვლება

თუ არ მიუთითებთ ios::ate (ან ios::app) დროშას, მაშინ Notebook.dat ორობითი ფაილის გახსნისას მისი წინა შიგთავსი წაიშლება!

დაბოლოს, შესაძლებელია ფაილის ერთდროულად გახსნა წასაკითხად/ჩასაწერად, წინამორბედებისგან fstream ნაკადის კლასის მიერ მემკვიდრეობით მიღებული მეთოდების გამოყენებით. ვინაიდან fstream კლასი მიღებულია istream-დან და ostream-დან (ifstream-ის და ofstream-ის მშობლები შესაბამისად), ყველა ადრე აღნიშნული მეთოდი ხელმისაწვდომი ხდება აპლიკაციისთვის.

შემდეგი მაგალითი ცვლის პირველ და მესამე ჩანაწერებს Notebook.dat ფაილში.

#შეიცავს #შეიცავს #შეიცავს namespace std-ის გამოყენებით; struct Notes (char სახელი; char ტელეფონი; int ასაკი; ); int main() ( setlocale(LC_ALL, "რუსული"); შენიშვნები Note1, Note3; // ფაილის გახსნა ერთდროულად წაკითხვის/წერისთვის fstream ფაილის ("Notebook.dat", ios::binary | ios::in | ios:: out); file.seekg(2 * sizeof(Notes)); // იპოვეთ და წაიკითხეთ Note3 ფაილი. წაკითხვა ((char*)&Note3, sizeof(Notes)); file.seekg(0); // იპოვეთ და წაიკითხეთ შენიშვნა1 file.read((char*)&Note1, sizeof(Notes)); file.seekg(0); // Note1<== Note3 file.write((char*)&Note3, sizeof(Notes)); file.seekg(2 * sizeof(Notes)); // Note3 <== Note1 file.write((char*)&Note1, sizeof(Notes)); char str; // Считывать и отображать записи в цикле, пока не eof file.seekg(0); // вернуться к началу файла while (!file.read((char*)&Note1, sizeof(Notes)).eof()) { sprintf(str, "%s\tТел: %s\tВозраст: %d", Note1.Name, Note1.Phone, Note1.Age); cout << str << endl; } file.close(); cin.sync(); cin.get(); return 0; }

ios::in და ios::out დროშები უნდა იყოს მითითებული ფაილის ობიექტის კონსტრუქტორში, რათა დაუშვას წაკითხვის და ჩაწერის ერთდროულად ოპერაციები. ამ კოდის შესრულების შედეგად, Notebook.dat ორობითი ფაილის პირველი და მესამე ჩანაწერები შეიცვლება.

არის დამატებითი მაგალითები თემაზე.