1. Bekerja dengan fail dalam C (berfungsi dalam C++ juga)..
#termasuk
#termasuk
batal utama (kosong)
{
FAIL *fail;
char* nama_fail = "file.txt";
char load_string = "tiada";
Fail = fopen(nama_fail, "w");
Fputs("rentetan", fail);
Fail = fopen(nama_fail, "r");
if(fail != 0)
{
fgets(load_string, 50 , fail);
cout)
lain
{
cout)
fclose(fail);
) Penerangan tentang fungsi untuk bekerja dengan fail terdapat dalam perpustakaan stdio.h
Mula-mula anda perlu mencipta penunjuk kepada pembolehubah jenis FILE ( FAIL* fail;).
Membuka fail dilakukan dengan memanggil fungsi fopen ( fail = fopen(nama_fail, "w");)
Parameter pertama fungsi ini ialah nama fail, yang kedua menentukan dalam mod apa fail harus dibuka. "w"- terbuka untuk rakaman, "r"- terbuka untuk membaca, "a"- penambahan fail (ini adalah mod yang paling banyak digunakan, walaupun terdapat yang lain). Menulis dan membaca data daripada fail dijalankan oleh fungsi berikut: fputc, fputs, fgetc, fgets, fprintf, fscanf(untuk penerangan tentang fungsi ini, lihat stdio.h).
Menutup fail dilakukan dengan memanggil fungsi fclose ( fclose(fail);).
Pustaka MFC termasuk beberapa kelas untuk bekerja dengan fail. Kelas yang dibincangkan di bawah mewarisi daripada kelas asasBekerja dengan fail menggunakan MFC (kelas CFile, CStdioFile, ...) dan kelas MFC standard CFileDialog.
Kelas CF ile
CFiledireka untuk berfungsi dengan fail. Ia menjadikan fail lebih mudah digunakan dengan mewakili fail sebagai objek yang boleh dibuat, dibaca, ditulis, dsb.Untuk mengakses fail, anda perlu mencipta objek kelas CFile terlebih dahulu. Pembina kelas membolehkan anda membuka fail sejurus selepas mencipta objek sedemikian. Tetapi anda boleh membuka fail kemudian menggunakan kaedah tersebut
Buka.Membuka dan mencipta fail
Selepas mencipta objek kelas CFileanda boleh membuka fail dengan memanggil kaedahBuka. Kaedah mesti menentukan laluan ke fail untuk dibuka dan mod penggunaannya. Prototaip kaedahBukamempunyai bentuk berikut:
Virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError=NULL); Sebagai parameter lpszFileName, anda mesti menentukan nama fail untuk dibuka. Anda boleh menentukan hanya nama fail atau nama fail penuh yang termasuk laluan penuh kepadanya. Parameter kedua, nOpenFlags, menentukan tindakan yang dilakukan oleh kaedah Buka pada fail, serta atribut fail. Di bawah ialah beberapa nilai yang mungkin untuk parameter nOpenFlags:
PError parameter pilihan, yang merupakan penunjuk kepada objek kelas CFileException, hanya digunakan jika menjalankan operasi pada fail akan menyebabkan ralat. Dalam kes ini, maklumat tambahan akan ditulis pada objek yang ditunjuk oleh pError.
Kaedah Bukamengembalikan bukan sifar jika fail dibuka dan sifar apabila ralat. Ralat semasa membuka fail boleh berlaku, contohnya, jika kaedah Buka ditentukan untuk membaca fail yang tidak wujud.
Buka ID fail
Kelas CFile termasuk elemen data m_hFile jenis UINT. Ia menyimpan pengecam fail yang terbuka. Jika objek kelas CFile telah dibuat, tetapi fail belum dibuka, maka pemalar hFileNull ditulis dalam pembolehubah m_hFile.
Biasanya pengecam fail terbuka tidak digunakan secara langsung. Kaedah Kelas CFilemembolehkan anda melakukan hampir semua operasi dengan fail dan tidak memerlukan anda untuk menentukan pengecam fail. Memandangkan m_hFile ialah elemen kelas, pelaksanaan kaedahnya sentiasa mempunyai akses percuma kepadanya.
Menutup fail
Selepas selesai bekerja dengan fail, ia mesti ditutup. Kelas CFilemempunyai kaedah Tutup khas untuk ini. Perlu diingatkan bahawa jika objek kelas CFile dicipta dan fail dibuka, dan kemudian objek dipadamkan, fail yang berkaitan ditutup secara automatik menggunakan pemusnah.
Membaca dan menulis fail
Terdapat beberapa kaedah kelas untuk mengakses fail. CFile: Baca, BacaHuge, Tulis, TulisBesar, Siram. Kaedah Baca dan BacaHuge direka untuk membaca data daripada fail yang dibuka sebelum ini. Pada sistem pengendalian 32-bit, kedua-dua kaedah secara serentak boleh membaca lebih daripada 65535 bait daripada fail. Spesifikasi ReadHuge dianggap usang dan dikekalkan hanya untuk keserasian dengan sistem pengendalian 16-bit.
Data yang dibaca daripada fail ditulis kepada penimbal lpBuf. Parameter nCount menentukan bilangan bait untuk dibaca daripada fail. Malah, lebih sedikit bait boleh dibaca daripada fail daripada yang diminta oleh parameter nCount. Ini berlaku jika hujung fail dicapai semasa membaca. Kaedah mengembalikan bilangan bait yang dibaca daripada fail.
Kaedah Write dan WriteHuge bertujuan untuk menulis ke fail. Pada sistem pengendalian 32-bit, kedua-dua kaedah secara serentak boleh menulis lebih daripada 65535 bait ke fail. Kaedah menulis bait daripada penimbal lpBuf ke fail terbuka nCount. Jika ralat tulis berlaku, seperti cakera penuh, kaedah memerlukan pengendalian pengecualian.
Kaedah siram
Apabila kaedah Write atau WriteHuge digunakan untuk menulis data ke cakera, ia mungkin kekal dalam penimbal sementara untuk beberapa lama. Untuk memastikan bahawa perubahan yang diperlukan dibuat pada fail pada cakera, anda perlu menggunakan kaedah Flush.
Operasi Fail
Kelas termasuk kaedah yang membolehkan anda melakukan pelbagai operasi pada fail, seperti menyalin, menamakan semula, memadam, menukar atribut.
Untuk menukar nama fail, kelas CFile termasuk kaedah statik Namakan semula, yang melaksanakan fungsi arahan ini. Kaedah ini tidak boleh digunakan untuk menamakan semula direktori. Jika ralat berlaku, kaedah itu menimbulkan pengecualian.
Kaedah statik disertakan dalam kelas CFile untuk memadam fail Alih keluar, yang membolehkan anda memadam fail yang ditentukan. Kaedah ini tidak membenarkan anda memadam direktori. Jika fail tidak boleh dipadamkan, kaedah membuang pengecualian.
Untuk menentukan tarikh dan masa penciptaan fail, panjang dan atributnya, kaedah statik digunakan GetStatus. Terdapat dua jenis kaedah - yang pertama ditakrifkan sebagai kaedah maya dan yang kedua ditakrifkan sebagai kaedah statik.
Versi maya kaedah GetStatusmenentukan keadaan terbuka fail yang dikaitkan dengan objek kelas CFile ini. Kaedah ini dipanggil hanya apabila objek kelas CFile dibuat dan fail dibuka.
Versi statik kaedah GetStatusmembolehkan anda menentukan ciri-ciri fail yang tidak dikaitkan dengan objek kelas CFile. Untuk menggunakan kaedah ini, tidak perlu membuka fail terlebih dahulu.
Kunci
Kelas termasuk kaedah Rangkaian Kunci Dan Julat Buka Kunci, yang membenarkan satu atau lebih keping data fail dikunci untuk akses oleh proses lain. Jika aplikasi cuba mengunci semula data yang sebelum ini dikunci oleh aplikasi ini atau aplikasi lain, pengecualian akan dilemparkan. Mengunci adalah salah satu mekanisme yang membolehkan beberapa aplikasi atau proses berfungsi secara serentak pada fail yang sama tanpa mengganggu satu sama lain.
Anda boleh menetapkan kunci menggunakan kaedah Rangkaian Kunci. Untuk mengalih keluar kunci yang dipasang, anda perlu menggunakan kaedah tersebutJulat Buka Kunci. Jika beberapa kunci ditetapkan dalam satu fail, maka setiap satu daripadanya mesti dilepaskan dengan panggilan kaedah yang berasinganJulat Buka Kunci.
Kedudukan
Untuk mengalihkan penunjuk kedudukan fail semasa ke kedudukan baharu, anda boleh menggunakan salah satu kaedah kelas berikut CFile - Cari, SeekToBegin, SeekToEnd. Ke kelas CFilejuga termasuk kaedah yang membolehkan anda menetapkan dan menukar panjang fail, -GetLength, SetLength.
Apabila membuka fail, penunjuk kedudukan fail semasa terletak di bahagian paling awal fail. Apabila sekeping data dibaca atau ditulis, penunjuk kedudukan semasa bergerak ke arah penghujung fail dan menghala ke data yang akan dibaca atau ditulis oleh operasi baca atau tulis seterusnya ke fail.
Untuk mengalihkan penunjuk kedudukan fail semasa ke mana-mana lokasi, anda boleh menggunakan kaedah universal
Cari. Ia membolehkan anda mengalihkan penunjuk bilangan bait tertentu berbanding kedudukan permulaan, akhir atau penunjuk semasa.Untuk mengalihkan penunjuk ke permulaan atau penghujung fail, adalah paling mudah untuk menggunakan kaedah khas. Kaedah
SeekToBeginmenggerakkan penunjuk ke permulaan fail, dan kaedahSeekToEnd- hingga ke penghujungnya.Tetapi untuk menentukan panjang fail yang terbuka, ia tidak perlu untuk mengalihkan penunjuknya. Anda boleh menggunakan kaedah tersebut
GetLength. Kaedah ini juga mengembalikan panjang fail terbuka dalam bait. KaedahSetLengthmembolehkan anda menukar panjang fail yang dibuka. Jika kaedah ini meningkatkan saiz fail, nilai bait terakhir tidak ditentukan.Kedudukan penunjuk fail semasa boleh ditentukan menggunakan kaedah
GetPosition. Dipulangkan mengikut kaedahGetPositionNilai 32-bit menentukan offset penuding dari permulaan fail.Buka Ciri Fail
Untuk menentukan lokasi fail terbuka pada cakera, anda perlu memanggil kaedah tersebut GetFilePath. Kaedah ini mengembalikan objek kelasCString, yang mengandungi laluan penuh fail, termasuk nama pemacu, direktori, nama fail dan sambungan fail.
Jika anda hanya perlu menentukan nama dan sambungan fail yang terbuka, anda boleh menggunakan kaedah tersebut GetFileName. Ia mengembalikan objek CString yang mengandungi nama fail. Dalam kes apabila anda perlu mengetahui hanya nama fail yang terbuka tanpa sambungan, gunakan kaedah tersebutGetFileTitle.
Kaedah kelas CFile berikut membolehkan anda menetapkan laluan fail. Kaedah ini tidak mencipta, menyalin atau menukar nama fail; ia hanya mengisi elemen data yang sepadan dalam objek kelas CFile.
Kelas C
MemFilePerpustakaan MFC termasuk kelas
CMemFile, diwarisi daripada kelas asasCFile. Kelas CMemFilemewakili fail yang terletak dalam RAM. Dengan objek kelasCMemFilesama seperti dengan objek kelasCFile. Perbezaannya ialah fail yang dikaitkan dengan objekCMemFile, tidak terletak pada cakera, tetapi dalam RAM komputer. Disebabkan ini, operasi dengan fail sedemikian jauh lebih cepat daripada dengan fail biasa.Bekerja dengan Objek Kelas
CMemFile, anda boleh menggunakan hampir semua kaedah kelasCFileyang telah diterangkan di atas. Anda boleh menulis data pada fail sedemikian atau membacanya. Sebagai tambahan kepada kaedah ini, kelas mengandungiCMemFilekaedah tambahan disertakan.Terdapat dua pembina berbeza untuk mencipta objek kelas CMemFile. Pembina CMemFile pertama hanya mempunyai satu parameter pilihan nGrowBytes:
CMemFile(UINT nGrowBytes=1024);Pembina ini mencipta fail kosong dalam RAM. Setelah dibuat, fail dibuka secara automatik (tidak perlu memanggil kaedah Open
n).Apabila menulis ke fail sedemikian bermula, blok memori diperuntukkan secara automatik. Untuk mendapatkan kaedah kelas memori
CMemFilememanggil fungsi standardmalloc, realloc Dan percuma. Jika blok memori yang diperuntukkan tidak mencukupi, saiznya meningkat. Blok memori fail ditambah dalam bahagian nGrowBytes bait. Selepas memadam objek kelasCMemFilememori yang digunakan dikembalikan secara automatik ke sistem.Pembina kedua kelas CMemFile mempunyai prototaip yang lebih kompleks. Pembina ini digunakan dalam kes di mana pengaturcara sendiri memperuntukkan memori untuk fail:
CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes=0);Parameter lpBuffer menentukan penimbal yang akan digunakan untuk fail. Saiz penimbal ditentukan oleh parameter nBufferSize.
Parameter nGrowBytes pilihan digunakan secara lebih komprehensif daripada dalam pembina kelas pertama. Jika nGrowBytes mengandungi sifar, maka fail yang dihasilkan akan mengandungi data daripada lpBuffer. Panjang fail sedemikian akan sama dengan nBufferSize.
Jika nGrowBytes lebih besar daripada sifar, maka kandungan lpBuffer diabaikan. Di samping itu, jika lebih banyak data ditulis pada fail sedemikian daripada yang boleh dimuatkan dalam penimbal yang diperuntukkan, saiznya secara automatik meningkat. Blok memori fail ditambah dalam bahagian nGrowBytes bait.
CMemFilemembolehkan anda mendapatkan penunjuk ke kawasan memori yang digunakan oleh fail. Melalui penunjuk ini anda boleh terus bekerja dengan kandungan fail, tanpa mengehadkan diri anda kepada kaedah kelasCFile. Untuk mendapatkan penunjuk kepada penimbal fail, anda boleh menggunakan kaedah Detach. Sebelum melakukan ini, adalah berguna untuk menentukan panjang fail (dan oleh itu saiz penimbal memori) dengan memanggil kaedahGetLength. Tanggalkanmenutup fail yang diberikan dan mengembalikan penunjuk ke blok memori yang digunakannya. Jika anda sekali lagi perlu membuka fail dan mengaitkan blok RAM dengannya, anda perlu memanggil kaedah tersebutLampirkan.Perlu diingatkan bahawa untuk menguruskan penimbal fail, kelas
CMemFilememanggil fungsi standardmalloc, realloc Dan percuma. Oleh itu, untuk tidak memecahkan mekanisme pengurusan memori, penimbal lpBuffer mesti dicipta oleh fungsimalloc atau calloc.Kelas CstdioFile
Mereka yang biasa menggunakan fungsi aliran I/O daripada perpustakaan standard C dan C++ harus memberi perhatian kepada kelas
CstdioFile, diwarisi daripada kelas asasCFile. Kelas ini membolehkan anda melakukan I/O buffer dalam mod teks dan binari. Untuk objek kelasCstdioFileAnda boleh memanggil hampir semua kaedah kelas CFile.CstdioFiletermasuk elemen data m_pStream, yang mengandungi penunjuk ke fail yang terbuka. Jika objek kelasCstdioFiledicipta, tetapi fail belum dibuka atau ditutup, maka m_pStream mengandungi pemalar NULL.CstdioFilemempunyai tiga pembina yang berbeza. Pembina pertama kelas CStdioFile tidak mempunyai parameter. Pembina ini hanya mencipta objek kelas, tetapi tidak membuka sebarang fail. Untuk membuka fail, anda perlu memanggil kaedahBukakelas asasCFile.Pembina kelas kedua
CstdioFileboleh dipanggil jika fail sudah terbuka dan anda perlu mencipta objek baharu kelas CStdioFile dan mengaitkan fail terbuka dengannya. Pembina ini boleh digunakan jika fail dibuka dengan fungsi standardfopen. Parameter kaedah mesti mengandungi penunjuk ke fail yang diperoleh dengan memanggil fungsi standardfopen.Pembina ketiga boleh digunakan jika anda perlu mencipta objek kelas
CstdioFile, buka fail baharu dan kaitkan dengan objek yang baru dibuat.Untuk membaca dan menulis ke fail teks, kelas CstdioFile termasuk dua kaedah baharu:
ReadString Dan WriteString. Kaedah pertama membolehkan anda membaca rentetan aksara daripada fail, dan kaedah kedua membolehkan anda menulisnya.Contoh penulisan dan bacaan daripada fail
Berikut ialah serpihan kod yang menunjukkan penggunaan panel dialog pemilihan fail standard dan prosedur untuk membaca dan menulis pada fail.
Membuka fail dan membaca daripadanya
CString m_Teks; …… // mencipta panel pemilihan fail standard Buka CFileDialog DlgOpen(TRUE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY,(LPCSTR)" Text Files (*.txt) |*.txt||"); // paparkan panel pemilihan fail standard Buka if(DlgOpen.DoModal()==IDOK) ( // cipta objek dan buka fail untuk dibaca Fail CStdioFail(DlgOpen.GetPathName(),CFile::modeRead|CFile::typeBinary); // membaca rentetan daripada fail CString& ref=m_Teks; File.ReadString(rujuk ); // rujukan kepada rentetan diluluskan m_Teks)Membuka dan menulis daripada fail
CString m_Teks; …… // mencipta panel pemilihan fail SaveAs standard CFileDialog DlgSaveAs(FALSE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, (LPCSTR)" Fail Teks (*.txt) |*.txt||"); // paparkan panel pemilihan fail SaveAs standard if(DlgSaveAs.DoModal()==IDOK) ( // cipta objek dan buka fail untuk menulis Fail CStdioFile(DlgSaveAs.GetPathName(), CFile::modeCreate|CFile::modeWrite|CFile::typeBinary); // tulis pada fail rentetan File.WriteString((LPCTSTR)m_Teks); )- mengandungi kod kerja program, direka untuk kesederhanaan sebagai aplikasi konsol di bawah MFC. Agar program berfungsi, jangan lupa lakukan perkara berikut:
Jalankan program - Bina / Bina semula semua (akan ada ralat), pilih Bina / Tetapkan konfigurasi aktif - Win 32 Realise, pilih item menu "Projek", kemudian "Tetapan...", tab "C/C++", Kategori - Penjanaan Kod dan Dalam item "Gunakan pustaka masa jalan", pilih "Berbilang Thread". Selepas itu, lakukan Bina / Bina Semula sekali lagi dan program akan berfungsi.
Fail teks
Mari kita lihat bekerja dengan fail teks dalam C menggunakan contoh. Cipta fail teks pada pemacu C bernama TextFile.txt. Taip baris berikut dalam fail ini:
String_1 123 String_11, 456
Rentetan_2
Rentetan_3
Simpan fail.
Dan ini ialah kod untuk program C yang membuka fail kami dan membaca baris daripadanya:
/* *Pengarang: @pengarang Subbotin B.P..h> #include
Untuk membuka fail teks dalam C, gunakan fungsi fopen:
FAIL *pTextFile = fopen("C:\\TextFile.txt", "r");
Argumen pertama kepada fungsi fopen menunjuk ke fail, dan yang kedua mengatakan bahawa fail itu terbuka untuk dibaca daripadanya.
Kami membaca baris menggunakan fungsi fgets:
fgets(cArray, LEN, pTextFile);
Argumen pertama bagi fungsi fgets menunjuk kepada tatasusunan aksara di mana rentetan yang diterima akan disimpan, argumen kedua ialah bilangan maksimum aksara untuk dibaca dan yang ketiga ialah fail kami.
Selepas selesai bekerja dengan fail, anda perlu menutupnya:
fclose(pTextFile);
Kita mendapatkan:
Huruf Rusia juga muncul dalam baris.
By the way, saya membuat program ini dalam Eclipse. Anda boleh melihat cara bekerja dengan C/C++ dalam Eclipse.
Jadi, kami membuka dan membaca data daripada fail teks.
Sekarang kita akan belajar cara membuat fail teks secara pemrograman dan menulis data kepadanya.
/* Pengarang: @pengarang Subbotin B.P..h> #include
Buat fail teks untuk menulis data kepada:
FAIL *pTextFile = fopen("C:\\TextFileW.txt", "w");
jika fail itu sudah wujud, ia akan dibuka dan semua data daripadanya akan dipadamkan.
C-string cString dan nombor nVal ditulis oleh atur cara kepada fail teks. cNewLine hanyalah baris baharu.
Kami menulis data ke fail teks menggunakan fungsi fprintf:
fprintf(pTextFile, "%s%c", cString, cNewLine);
hujah pertama di sini ialah fail kami, yang kedua ialah rentetan format, yang ketiga atau lebih ialah bilangan argumen yang diperlukan untuk format ini.
Kepada pengaturcara, fail terbuka diwakili sebagai urutan data yang dibaca atau ditulis. Apabila fail dibuka, ia dikaitkan dengan Strim I/O . Maklumat output ditulis ke aliran, maklumat input dibaca dari aliran.
Apabila strim dibuka untuk I/O, ia dikaitkan dengan struktur FILE standard, yang ditakrifkan dalam stdio.h. Struktur FILE mengandungi maklumat yang diperlukan tentang fail.
Membuka fail dilakukan menggunakan fungsi fopen(), yang mengembalikan penunjuk kepada struktur jenis FILE yang boleh digunakan untuk operasi seterusnya pada fail.
FAIL *fopen(nama, jenis);
nama – nama fail untuk dibuka (termasuk laluan),
taip - penunjuk kepada rentetan aksara yang menentukan cara fail diakses:
· "r" - buka fail untuk dibaca (fail mesti wujud);
· "w" - buka fail kosong untuk menulis; jika fail itu wujud, kandungannya hilang;
· "a" - buka fail untuk menulis hingga akhir (untuk dilampirkan); fail dibuat jika ia tidak wujud;
· "r+" - buka fail untuk membaca dan menulis (fail mesti wujud);
· "w+" - buka fail kosong untuk membaca dan menulis; jika fail itu wujud, kandungannya hilang;
· "a+" - buka fail untuk dibaca dan ditambah; jika fail itu tidak wujud, ia dicipta.
Nilai pulangan ialah penunjuk kepada aliran terbuka. Jika ralat dikesan, NULL dikembalikan.
Fungsi fclose() menutup strim atau strim yang dikaitkan dengan fail yang dibuka menggunakan fungsi fopen(). Strim yang akan ditutup ditentukan oleh hujah fungsi fclose().
Nilai pulangan: nilai 0 jika strim berjaya ditutup; EOF tetap jika ralat berlaku.
#termasuk
int utama()
char name="my.txt";
if(fp = fopen(nama, "r")!=NULL)
// adakah mungkin untuk membuka fail?
... // tindakan yang diperlukan pada data
else printf("Gagal membuka fail");
Membaca aksara daripada fail:
char fgetc(strim);
Argumen fungsi ialah penunjuk kepada aliran jenis FILE. Fungsi ini mengembalikan kod aksara yang dibaca. Jika penghujung fail dicapai atau ralat berlaku, EOF malar dikembalikan.
Menulis simbol pada fail:
fputc(char, strim);
Argumen fungsi ialah aksara dan penunjuk kepada aliran jenis FILE. Fungsi ini mengembalikan kod aksara yang dibaca.
Fungsi fscanf() dan fprintf() adalah serupa dengan fungsi scanf() dan printf(), tetapi berfungsi dengan fail data dan mempunyai penuding ke fail sebagai hujah pertamanya.
fscanf(strim, "Format Input", argumen);
fprintf(strim, "Format Output", argumen);
Fungsi fgets() dan fputs() direka untuk input/output rentetan; ia serupa dengan fungsi gets() dan puts() untuk bekerja dengan fail.
fgets(Tuding Ke Baris, Bilangan Aksara, aliran);
Aksara dibaca daripada strim sehingga aksara baris baharu "\n" dibaca, yang disertakan dalam rentetan atau sehingga strim tamat EOF atau bilangan maksimum aksara telah dibaca. Hasilnya diletakkan dalam penuding rentetan dan berakhir dengan aksara nol "\0". Fungsi mengembalikan alamat rentetan.
fputs(Tuding Kepada Rentetan, strim);
Menyalin rentetan ke strim dari kedudukan semasa. Aksara null yang ditamatkan tidak disalin.
Contoh
Masukkan nombor dan simpan dalam fail s1.txt. Baca nombor dari fail s1.txt, tambahkan sebanyak 3 dan simpan dalam fail s2.txt.
Bekerja dengan fail teks dalam C++.
Terdapat dua jenis fail utama: teks dan binari. Fail membenarkan pengguna membaca sejumlah besar data terus dari cakera tanpa perlu memasukkannya dari papan kekunci.
Teks fail yang terdiri daripada sebarang aksara dipanggil. Ia disusun mengikut baris, setiap satu berakhir dengan watak akhir baris. Hujung fail itu sendiri ditunjukkan oleh simbol "akhir fail". Apabila menulis maklumat ke fail teks, yang boleh dilihat menggunakan mana-mana editor teks, semua data ditukar kepada jenis aksara dan disimpan dalam bentuk aksara.
DALAM binari Dalam fail, maklumat dibaca dan ditulis dalam bentuk blok saiz tertentu, di mana data apa-apa jenis dan struktur boleh disimpan.
Untuk bekerja dengan fail, istimewa jenis data, dipanggil aliran. Aliran ifstream digunakan untuk bekerja dengan fail dalam mod membaca, dan ofstream dalam mod rakaman. Untuk bekerja dengan fail dalam kedua-dua mod menulis dan membaca, strim digunakan fstream.
Dalam program C++, apabila bekerja dengan fail teks, anda mesti memasukkan perpustakaan iostream dan fstream.
Untuk menulis data ke fail teks, anda memerlukan:
menerangkan pembolehubah jenis aliran.
maklumat output ke fail.
pastikan anda menutup fail.
Untuk membaca data daripada fail teks, anda memerlukan:
huraikan pembolehubah jenis ifstream.
buka fail menggunakan fungsi terbuka.
tutup fail.
Rekod maklumat kepada fail teks
Seperti yang dinyatakan sebelum ini, untuk mula bekerja dengan fail teks, anda perlu menentukan pembolehubah jenis aliran. Sebagai contoh, seperti ini:
Pembolehubah F akan dibuat untuk menulis maklumat pada fail.
Pada peringkat seterusnya, fail mesti dibuka untuk menulis. Secara umum, pengendali pembukaan strim akan kelihatan seperti:
F.open("fail", mod);
Di sini F ialah pembolehubah yang diterangkan sebagai ofstream,
fail - nama penuh fail pada cakera,
mod - mod bekerja dengan fail yang dibuka.
Sila ambil perhatian bahawa apabila menentukan nama fail penuh, anda mesti menggunakan garis miring berganda. Sebagai contoh, nama penuh fail noobs.txt, yang terletak dalam folder permainan pada pemacu D:, perlu ditulis seperti ini:
D:\\permainan\\noobs.txt.
Fail boleh dibuka dalam salah satu mod berikut:
ios::in - buka fail dalam mod bacaan data, mod ini ialah mod lalai untuk ifstreams;
ios::out - buka fail dalam mod penulisan data (dalam kes ini, maklumat tentang fail sedia ada dimusnahkan), mod ini ialah mod lalai untuk ofstreams;
ios::app - buka fail dalam mod menulis data ke penghujung fail;
ios::ate - pindah ke penghujung fail yang sudah dibuka;
ios::trunc - kosongkan fail, ini juga berlaku dalam mod ios::out;
ios::nocreate - jangan buka fail jika ia tidak wujud;
ios::noreplace - jangan buka fail sedia ada.
Parameter mod mungkin tiada, dalam hal ini fail dibuka dalam mod lalai untuk strim ini.
Selepas berjaya membuka fail (dalam mana-mana mod), pembolehubah F akan menyimpan benar, jika tidak palsu. Ini akan membolehkan anda menyemak ketepatan operasi pembukaan fail.
Anda boleh membuka fail (mari ambil fail D:\\game\\noobs.txt sebagai contoh) dalam mod rakaman dalam salah satu cara berikut:
// pertama cara
aliran F;
F.open("D:\\game\\noobs.txt", ios::out);
//kaedah kedua, mod ios::out ialah mod lalai
// Untuk aliranofstream
aliran F;
//kaedah ketiga menggabungkan penerangan pembolehubah dan jenis aliran
//dan membuka fail dalam satu kenyataan
ofstream F("D:\\game\\noobs.txt", ios::out);
Selepas membuka fail dalam mod tulis, fail kosong akan dibuat di mana anda boleh menulis maklumat.
Jika anda ingin membuka fail sedia ada dalam mod tulis dahulu, anda harus menggunakan ios::app sebagai mod.
Selepas membuka fail dalam mod rakaman, anda boleh menulis kepadanya dengan cara yang sama seperti pada skrin, hanya dan bukannya peranti output standardcoutanda mesti menyatakan nama fail yang dibuka.
Sebagai contoh, untuk menulis pembolehubah a ke aliran F, pernyataan output akan kelihatan seperti:
Untuk output berjujukan untuk menstrim G pembolehubah b, c, d, operator output akan menjadi seperti ini:
G< Menutup aliran dilakukan menggunakan operator: CONTOH: Cipta fail teks D:\\game\\noobs.txt dan tulis n nombor nyata ke dalamnya. #include "stdafx.h" #termasuk #termasuk #termasuk menggunakan ruang nama std; int utama() setlocale(LC_ALL, "RUS"); int i, n; ganda a; // menerangkan aliran untuk menulis data ke fail ofstream
f;
//buka fail dalam mod tulis, //modios::
keluardipasang secara lalai f.open("D:\\game\\noobs.txt", ios::out); //masukkan bilangan nombor nyata cout<<"
n=";
cin>>
n;
//gelung untuk memasukkan nombor nyata //dan tuliskannya pada fail untuk (i=0; i cout<<"a=";
//masukkan nombor cin>>a; f< //menutup aliran f.close(); sistem("jeda"); pulangan 0; _______________________________________________________________ Untuk membaca maklumat daripada fail teks, anda perlu menerangkan pembolehubah seperti ifstream. Selepas ini, anda perlu membuka fail untuk membaca menggunakan operator buka. Jika pembolehubah dipanggil F, maka dua pernyataan pertama akan menjadi seperti ini: F.open("D:\\game\\noobs.txt", ios::in); Selepas membuka fail dalam mod membaca, anda boleh membaca maklumat daripadanya dengan cara yang sama seperti dari papan kekunci, hanya sebaliknyacinnyatakan nama aliran dari mana data akan dibaca. Sebagai contoh, untuk membaca dari aliran F ke pembolehubah a, pernyataan input akan kelihatan seperti ini: Dua nombor dalam editor teks dianggap dipisahkan jika terdapat sekurang-kurangnya satu aksara di antaranya: ruang, tab, hujung baris. Adalah baik jika pengaturcara mengetahui terlebih dahulu berapa banyak dan nilai apa yang perlu disimpan dalam fail teks. Walau bagaimanapun, selalunya jenis nilai yang disimpan dalam fail hanya diketahui, tetapi bilangannya mungkin berbeza-beza. Untuk menyelesaikan masalah ini, anda perlu membaca nilai dari fail satu demi satu, dan sebelum setiap bacaan, semak sama ada penghujung fail telah dicapai. Terdapat fungsi untuk ini F.
eof().
Di sini F ialah nama benang, fungsi mengembalikan nilai Boolean: benar atau salah, bergantung pada sama ada penghujung fail dicapai. Oleh itu, gelung untuk membaca kandungan keseluruhan fail boleh ditulis seperti ini: //mengatur untuk membaca nilai dari fail, pelaksanaan //gelung akan pecah apabila kita sampai ke penghujung fail, //dalam kes ini F.eof() akan kembali benar manakala (!F.eof()) CONTOH: Fail teks D:\\game\\noobs.txt menyimpan nombor nyata, memaparkannya pada skrin dan mengira nombornya. #include "stdafx.h" #termasuk #termasuk #termasuk #termasuk menggunakan ruang nama std; int utama() setlocale(LC_ALL, "RUS"); int n=0; terapung a; fstream F; //buka fail dalam mod membaca F.open("D:\\game\\noobs.txt"); //jika fail dibuka dengan betul, maka //gelung untuk membaca nilai dari fail; pelaksanaan gelung akan terganggu, //apabila kita sampai ke penghujung fail, dalam kes ini F.eof() akan kembali benar. manakala (!F.eof()) //membaca nilai seterusnya dari aliran F ke dalam pembolehubah a F>>a; //keluarkan nilai pembolehubah a ke skrin cout< //menambah bilangan nombor yang dibaca //menutup aliran F.close(); //masukan pada skrin bilangan nombor yang dibaca cout<<"n="< //jika pembukaan fail tidak betul, maka outputnya //mesej tentang ketiadaan fail sedemikian lain cout<<" Файл не существует"< sistem("jeda"); pulangan 0; C++. Pemprosesan fail binari Apabila menulis maklumat ke fail binari, aksara dan nombor ditulis sebagai urutan bait. Untuk menulis data ke fail binari, anda perlukan: terangkan pembolehubah fail jenis FAIL * menggunakan FILE *nama fail; operator. Di sini nama fail ialah nama pembolehubah di mana penunjuk kepada fail akan disimpan. tulis maklumat pada fail menggunakan fungsi fwrite Untuk pertimbangkan b data daripada fail binari, anda perlukan: terangkan pembolehubah jenis FILE * buka fail menggunakan fungsi fopen tutup fail menggunakan fungsi fclose Fungsi asas yang diperlukan untuk berfungsi dengan fail binari. Untuk penemuan Fail ini bertujuan untuk fungsi fopen. FAIL *fopen(const *nama fail, const char *mod) Di sini nama fail ialah rentetan yang menyimpan nama penuh fail yang dibuka, mod ialah rentetan yang menentukan mod untuk bekerja dengan fail; nilai berikut mungkin: "rb" - buka fail binari dalam mod baca; "wb" - buat fail binari untuk rakaman; jika ia wujud, kandungannya dibersihkan; “ab” - cipta atau buka fail binari untuk ditambahkan pada penghujung fail; “rb+” - buka fail binari sedia ada dalam mod baca-tulis; "wb+" - buka fail binari dalam mod baca-tulis, fail sedia ada dikosongkan; "ab+" - fail binari dibuka atau dicipta untuk membetulkan maklumat sedia ada dan menambah maklumat baharu pada penghujung fail. Fungsi mengembalikan NULL dalam pembolehubah fail f jika fail dibuka tidak berjaya. Selepas membuka fail, bait ke-0nya tersedia, penunjuk fail ialah 0, nilainya, semasa ia dibaca atau ditulis, dialihkan oleh bilangan bait yang dibaca (ditulis). Nilai semasa penuding fail ialah nombor bait dari mana operasi baca atau tulis akan berlaku. Untuk penutup fail itu bertujuan untuk fungsi fclose int fclose(FAIL *nama fail); Mengembalikan 0 jika fail berjaya ditutup, NULL sebaliknya. Fungsi keluarkan adalah untuk penyingkiran fail. int remove(const char *nama fail); Fungsi ini memadamkan fail bernama filenema daripada cakera. Fail yang hendak dipadam mesti ditutup. Fungsi ini mengembalikan nilai bukan sifar jika fail tidak dapat dipadamkan. Untuk menamakan semula fail, fungsi nama semula dimaksudkan: int rename(const char *nama fail lama, const char *nama fail baharu); Parameter pertama ialah nama fail lama, yang kedua ialah yang baharu. Mengembalikan 0 jika program berjaya ditamatkan. Membaca dari fail binari dilakukan menggunakan fungsi fread: fread(void *ptr, saiz, n, FAIL *nama fail); Fungsi fread membaca n elemen saiz saiz daripada nama fail ke dalam ptr tatasusunan. Fungsi ini mengembalikan bilangan elemen yang dibaca. Selepas membaca daripada fail, penunjuknya dialihkan oleh bait saiz n*. Rekod ke fail binari dilakukan menggunakan fungsi fwrite: fwrite(const void *ptr, saiz, n, FAIL *nama fail); Fungsi fwrite menulis pada nama fail fail daripada ptr tatasusunan n elemen saiz saiz. Fungsi ini mengembalikan bilangan elemen yang ditulis. Selepas menulis maklumat pada fail, penunjuk dialihkan oleh bait saiz n*. Untuk kawalan akhir fail terdapat fungsi feof: int feof(FAIL *nama fail); Ia mengembalikan nilai bukan sifar jika penghujung fail dicapai. CONTOH: Cipta fail binari D:\\game\\noobs.dat dan tulis n integer dan n nombor nyata ke dalamnya. #include "stdafx.h" #termasuk menggunakan ruang nama std; int utama() setlocale(LC_ALL, "RUS"); int n, i; ganda a; //buat fail binari dalam mod tulis f=fopen("D:\\game\\noobs.dat", "wb"); //
input
nomborn cout<<"n=";
cin>>n; fwrite(&n, sizeof(int), 1, f); //gelung untuk memasukkan n nombor nyata untuk (i=0; i //masukkan nombor sebenar seterusnya cout<<"a=";
cin>>a; //menulis nombor nyata pada fail binari fwrite(&a, sizeof(double), 1, f); //
dekat
fail fclose(f); sistem("jeda"); pulangan 0; CONTOH: Paparkan kandungan fail binari D:\\game\\noobs.dat yang dibuat dalam tugasan sebelumnya #include "stdafx.h" #termasuk menggunakan ruang nama std; int utama() setlocale(LC_ALL, "RUS"); int n, i; ganda *a; FAIL *f; //terangkan pembolehubah fail //buka fail binari sedia ada dalam mod baca //baca satu integer daripada fail ke dalam pembolehubah n //output n ke skrin cout<<"n="< //memperuntukkan memori untuk susunan n nombor a=ganda baharu[n]; //membaca n nombor nyata daripada fail ke dalam tatasusunan a //keluarkan tatasusunan ke skrin untuk (i=0; i cout< cout< //
dekat
fail fclose(f); sistem("jeda"); pulangan 0; Fail binari- struktur data berurutan, selepas membuka fail, bait pertama yang disimpan di dalamnya tersedia. Anda boleh menulis atau membaca data daripada fail secara berurutan. Katakan anda perlu mengira nombor kelima belas, dan kemudian yang pertama. Menggunakan akses berurutan ini boleh dilakukan dengan cara berikut: int n, i; ganda a; FAIL *f; f=fopen("D:\\game\\noobs.dat", "rb"); untuk (i=0; i<15; i++)
fclose(f); f=fopen("D:\\game\\noobs.dat", "rb"); fread(&a, sizeof(double), 1, f); fclose(f); Seperti yang anda lihat, membaca nombor daripada fail dan kemudian membuka fail semula bukanlah cara yang paling mudah. Ia akan menjadi lebih mudah untuk menggunakan fungsi fseek untuk mengalihkan penuding fail ke bait tertentu. int fseek(FAIL *nama fail, offset int panjang, asal int); Fungsi ini menetapkan penunjuk kedudukan fail semasa F mengikut nilai asal dan mengimbangi. Parameter offset adalah sama dengan bilangan bait yang mana penuding fail akan diimbangi berbanding dengan asal yang ditentukan oleh parameter asal. Nilai untuk parameter asal mestilah salah satu daripada nilai offset berikut yang ditakrifkan dalam pengepala stdio.h: SEEK_SET - dari permulaan fail; SEEK_CUR - dari kedudukan semasa; SEEK_END - dari hujung fail. Fungsi mengembalikan nilai sifar jika operasi berjaya, nilai bukan sifar jika offset gagal. Fungsi fseek sebenarnya melaksanakan akses terus kepada sebarang nilai dalam fail. Anda hanya perlu mengetahui lokasi (nombor bait) nilai dalam fail. Mari kita lihat menggunakan akses terus dalam fail binari menggunakan masalah berikut sebagai contoh. CONTOH Dalam fail binari D:\\game\\noobs.dat yang dibuat sebelum ini, tukar nombor nyata terbesar dan terkecil. Algoritma untuk menyelesaikan masalah terdiri daripada peringkat berikut: membaca reals daripada fail ke dalam tatasusunan a. cari dalam tatasusunan a untuk nilai maksimum (maks) dan minimum (min) dan nombornya (imax, imin). mengalihkan penuding fail ke nilai maksimum dan menulis min. mengalihkan penuding fail ke nilai minimum dan menulis maks. Di bawah ialah teks program untuk menyelesaikan masalah dengan ulasan. #include "stdafx.h" #termasuk menggunakan ruang nama std; int utama() setlocale(LC_ALL, "RUS"); int n, i, imax, imin; ganda *a, maks, min; FAIL *f; //buka fail dalam mod baca-tulis f=fopen("D:\\game\\noobs.dat", "rb+"); //baca nombor daripada fail kepada pembolehubah n //nombor nyata dalam fail fread(&n, saiz(int), 1, f); cout<<"n="< //peruntukkan memori untuk menyimpan nombor nyata, //yang akan disimpan dalam tatasusunan a a=ganda baharu[n]; //baca daripada fail ke dalam tatasusunan dan nombor nyata fread(a, saiz(berganda), n, f); //cari elemen maksimum dan minimum //dalam tatasusunan a dan indeksnya untuk (imax=imin=0, max=min=a, i=1; i jika (a[i]> maks) maks=a[i]; jika (a[i] min=a[i]; //
bergerak
penunjuk
Kepada
maksimum
unsur fseek(f, sizeof(int)+imax*sizeof(double), SEEK_SET); //tulis min dan bukannya elemen fail maksimum fwrite(&min, sizeof(double), 1, f); //
bergerak
penunjuk
Kepada
minimum
unsur fseek(f, sizeof(int)+imin*sizeof(double), SEEK_SET); //rekod maks dan bukannya elemen fail minimum fwrite(&max, sizeof(double), 1, f); //menutup fail fclose(f); //membebaskan ingatan padam [
]a; sistem("jeda"); Kebanyakan program komputer berfungsi dengan fail, dan oleh itu terdapat keperluan untuk mencipta, memadam, menulis, membaca, membuka fail. Apakah fail? Fail ialah set bait bernama yang boleh disimpan pada beberapa peranti storan. Nah, kini jelas bahawa fail bermaksud jujukan bait tertentu yang mempunyai nama uniknya sendiri, contohnya file.txt. Fail dengan nama yang sama tidak boleh ditempatkan dalam direktori yang sama. Nama fail merujuk bukan sahaja pada namanya, tetapi juga pada sambungannya, contohnya: file.txt dan file.dat —
fail yang berbeza, walaupun mereka mempunyai nama yang sama. Terdapat perkara seperti nama fail penuh - ini ialah alamat penuh kepada direktori fail yang menunjukkan nama fail, contohnya: D:\docs\file.txt. Adalah penting untuk memahami konsep asas ini, jika tidak, ia akan menjadi sukar untuk bekerja dengan fail. Untuk bekerja dengan fail, anda perlu memasukkan fail pengepala I/O Fail adalah serupa dengan I/O standard, satu-satunya perbezaan ialah I/O dilakukan pada fail dan bukannya pada skrin. Jika I/O kepada peranti standard dilakukan menggunakan objek cin dan cout, maka untuk mengatur fail I/O sudah cukup untuk mencipta objek anda sendiri yang boleh digunakan sama dengan pengendali cin dan cout. Sebagai contoh, anda perlu mencipta fail teks dan menulis baris Bekerja dengan fail dalam C++ ke dalamnya. Untuk melakukan ini, anda perlu mengambil langkah berikut: Mengapakah perlu mencipta objek ofstream dan bukannya objek ifstream? Kerana anda perlu menulis pada fail, dan jika anda perlu membaca data daripada fail, objek kelas ifstream akan dibuat. // cipta objek untuk menulis ke fail ofstream /*nama objek*/; // objek kelas aliran Mari kita panggil objek fout. Inilah yang kita dapat: Ofstream fout; Mengapa kita memerlukan objek? Objek diperlukan untuk dapat menulis ke fail. Objek telah dibuat, tetapi tidak dikaitkan dengan fail yang mana rentetan itu perlu ditulis. Fout.open("cppstudio.txt"); // mengaitkan objek dengan fail Melalui operasi titik, kami mendapat akses kepada kaedah kelas open(), di mana kami menunjukkan nama fail dalam kurungan. Fail yang ditentukan akan dibuat dalam direktori semasa dengan program. Jika fail dengan nama yang sama wujud, fail sedia ada akan digantikan dengan yang baharu. Jadi, fail itu terbuka, yang tinggal hanyalah menulis baris yang diperlukan ke dalamnya. Ini dilakukan seperti ini: Fout<< "Работа с файлами в С++"; // запись строки в файл
Menggunakan operasi aliran bersama-sama dengan objek fout, rentetan Bekerja dengan fail dalam C++ ditulis pada fail. Oleh kerana tidak ada lagi keperluan untuk menukar kandungan fail, ia mesti ditutup, iaitu objek mesti dipisahkan daripada fail. Fout.close(); // tutup fail Keputusan - fail telah dicipta dengan baris Bekerja dengan fail dalam C++. Langkah 1 dan 2 boleh digabungkan, iaitu, dalam satu baris, cipta objek dan kaitkan dengan fail. Ini dilakukan seperti ini: Ofstream fout("cppstudio.txt"); // cipta objek kelas ofstream dan kaitkan dengan fail cppstudio.txt Mari gabungkan semua kod dan dapatkan program berikut. // file.cpp: Mentakrifkan titik masuk untuk aplikasi konsol. #include "stdafx.h" #include Ia tetap untuk memeriksa sama ada program berfungsi dengan betul, dan untuk melakukan ini, buka fail cppstudio.txt dan melihat kandungannya, ia sepatutnya - Bekerja dengan fail dalam C++. Program ini menunjukkan dua cara untuk membaca daripada fail, yang pertama menggunakan operasi pemindahan ke aliran, yang kedua menggunakan fungsi getline() . Dalam kes pertama, hanya perkataan pertama dibaca, dan dalam kes kedua, rentetan sepanjang 50 aksara dibaca. Tetapi oleh kerana terdapat kurang daripada 50 aksara yang tinggal dalam fail, aksara sehingga dan termasuk yang terakhir dibaca. Sila ambil perhatian bahawa membaca kali kedua (baris 17) diteruskan selepas perkataan pertama, dan bukan dari awal, sejak perkataan pertama dibaca dalambaris 14. Keputusan program ditunjukkan dalam Rajah 1. Bekerja dengan fail dalam C++ Untuk meneruskan, tekan sebarang kekunci. . . Rajah 1 - Bekerja dengan fail dalam C++ Program ini berfungsi dengan betul, tetapi ini tidak selalu berlaku, walaupun semuanya teratur dengan kod. Sebagai contoh, nama fail yang tidak wujud telah dihantar kepada program atau terdapat ralat dalam nama tersebut. Selepas itu, apa? Dalam kes ini, tiada apa yang akan berlaku sama sekali. Fail tidak akan ditemui, yang bermaksud ia tidak akan dapat dibaca. Oleh itu, pengkompil akan mengabaikan baris di mana kerja dilakukan pada fail. Akibatnya, program akan keluar dengan betul, tetapi tiada apa yang akan ditunjukkan pada skrin. Nampaknya ini adalah tindak balas yang benar-benar normal terhadap keadaan sedemikian. Tetapi pengguna mudah tidak akan memahami apa yang sedang berlaku dan mengapa baris dari fail tidak muncul pada skrin. Jadi, untuk menjadikan semuanya sangat jelas, C++ menyediakan fungsi sedemikian - is_open(), yang mengembalikan nilai integer: 1 - jika fail berjaya dibuka, 0 - jika fail tidak dibuka. Mari ubah suai program dengan membuka fail, supaya jika fail tidak dibuka, mesej yang sepadan dipaparkan. // file_read.cpp: Mentakrifkan titik masuk untuk aplikasi konsol. #include "stdafx.h" #include Keputusan program ditunjukkan dalam Rajah 2. Fail tidak boleh dibuka! Untuk meneruskan, tekan sebarang kekunci. . . Rajah 2 - Bekerja dengan fail dalam C++ Seperti yang dapat dilihat dari Rajah 2, program melaporkan bahawa adalah mustahil untuk membuka fail. Oleh itu, jika program berfungsi dengan fail, adalah disyorkan untuk menggunakan fungsi ini, is_open(), walaupun anda pasti bahawa fail itu wujud. Mod pembukaan fail menentukan cara fail digunakan. Untuk menetapkan mod, kelas ios_base menyediakan pemalar yang menentukan mod pembukaan fail (lihat Jadual 1). Mod pembukaan fail boleh ditetapkan terus apabila mencipta objek atau apabila memanggil fungsi open(). .
Ofstream fout("cppstudio.txt", ios_base::app); // buka fail untuk menambah maklumat pada penghujung fail fout.open("cppstudio.txt", ios_base::app); // buka fail untuk menambah maklumat pada penghujung fail Mod pembukaan fail boleh digabungkan menggunakan operasi logik bitwise atau| , sebagai contoh: ios_base::out | ios_base::trunc - membuka fail untuk menulis selepas mengosongkannya. Objek kelas ofstream, apabila dikaitkan dengan fail, secara lalai mengandungi mod pembukaan fail ios_base::out | ios_base::trunc .
Iaitu, fail akan dibuat jika ia tidak wujud. Jika fail itu wujud, kandungannya akan dipadamkan dan fail itu sendiri akan sedia untuk ditulis. Objek kelas ifstream, apabila dikaitkan dengan fail, mempunyai mod pembukaan fail lalai ios_base::in - fail dibuka baca sahaja. Mod pembukaan fail juga dipanggil bendera; untuk kebolehbacaan, kami akan menggunakan istilah ini pada masa hadapan. Jadual 1 tidak menyenaraikan semua bendera, tetapi ini sepatutnya mencukupi untuk anda bermula. Ambil perhatian bahawa bendera ate dan app adalah sangat serupa dalam perihalan, kedua-duanya mengalihkan penuding ke hujung fail, tetapi bendera aplikasi hanya membenarkan penulisan ke hujung fail dan bendera ate hanya menggerakkan bendera ke hujung fail dan tidak mengehadkan tempat untuk menulis. Mari bangunkan program yang, menggunakan operasi sizeof(), akan mengira ciri-ciri jenis data utama dalam C++ dan menulisnya pada fail. Ciri-ciri: Fail mesti ditulis dalam format berikut: /* bait jenis data nilai maks bool = 1 255.00 char = 1 255.00 int pendek = 2 32767.00 int pendek tidak bertanda = 2 65535.00 int = 4 2147483647.00 int tidak bertanda = 4 72948 = 4 72948 = 4 72948 00 int panjang yang tidak ditandatangani = 4 4294967295.00 apungan = 4 2147483647.00 apungan panjang = 8 9223372036854775800.00 ganda = 8 9223372036854775800.00 */ Program sedemikian telah dibangunkan lebih awal dalam bahagian itu, tetapi di sana semua maklumat tentang jenis data telah dikeluarkan kepada peranti keluaran standard, dan kita perlu membuat semula atur cara supaya maklumat itu ditulis pada fail. Untuk melakukan ini, anda perlu membuka fail dalam mod tulis, dengan pemangkasan awal maklumat fail semasa ( baris 14). Setelah fail dibuat dan berjaya dibuka (baris 16 - 20), bukannya pernyataan cout, dalam baris 22 kami menggunakan objek fout. oleh itu, bukannya skrin, maklumat jenis data akan ditulis pada fail. // write_file.cpp: Mentakrifkan titik masuk untuk aplikasi konsol. #include "stdafx.h" #include Adalah mustahil untuk tidak menyedari bahawa perubahan dalam program adalah minimum, dan semua terima kasih kepada fakta bahawa input/output standard dan input/output fail digunakan dengan cara yang sama. Pada akhir program, dibaris 45Kami secara eksplisit menutup fail, walaupun ini tidak perlu, tetapi dianggap sebagai amalan pengaturcaraan yang baik. Perlu diingat bahawa semua fungsi dan manipulator yang digunakan untuk memformat input/output standard juga relevan untuk input/output fail. Oleh itu, tiada ralat berlaku apabila penyataan cout digantikan dengan objek tewas.
// file_read.cpp: Mentakrifkan titik masuk untuk aplikasi konsol. #include "stdafx.h" #include Mod pembukaan fail
