Dalam artikel ini, kami akan menunjukkan kepada anda cara membaca dan menulis ke fail dalam bahasa pengaturcaraan C ++ dengan menggunakan beberapa contoh. Untuk memahami operasi fail C ++ seperti membaca dan menulis, kita mesti terlebih dahulu memahami konsep aliran dalam C ++.
Apa itu Aliran?
Aliran hanyalah aliran data atau watak. Terdapat dua jenis aliran: aliran input dan aliran output. Aliran input digunakan untuk membaca data dari perangkat input luaran seperti papan kekunci, sementara aliran output digunakan untuk menulis data ke perangkat output luaran seperti monitor. Fail boleh dianggap sebagai sumber input dan output.
Di C ++, kami menggunakan aliran untuk mengirim atau menerima data ke atau dari sumber luaran.
Kita boleh menggunakan kelas terbina dalam untuk mengakses aliran input / output, iaitu ios.
Berikut adalah hierarki kelas aliran bahasa pengaturcaraan C ++:
Objek cin dan cout digunakan untuk membaca data dari papan kekunci dan untuk menampilkan output pada monitor. Selain itu, ifstream, yang merupakan singkatan dari aliran file input, digunakan untuk membaca aliran data dari file, dan ofstream, yang merupakan singkatan dari aliran file output, digunakan untuk menulis aliran data ke file.
Fail iostram.h mengandungi semua kelas aliran input / output standard yang diperlukan dalam bahasa pengaturcaraan C ++.
Contoh
Setelah anda memahami asas aliran, kami akan membincangkan contoh berikut untuk membantu anda memahami operasi fail dengan lebih baik di C ++:
- Contoh 1: Buka dan Tutup Fail
- Contoh 2: Tulis ke Fail
- Contoh 3: Baca dari Fail
- Contoh 4: Baca dan Tulis ke Fail
- Contoh 5: Baca dan Tulis ke Fail Binari
Contoh 1: Buka dan Tutup Fail
Dalam program contoh ini, kami akan menunjukkan cara membuka / membuat fail dan cara menutup fail di C ++. Seperti yang anda lihat dalam program di bawah, kami telah memasukkan perpustakaan yang diperlukan untuk operasi fail.
Untuk membuka dan menutup fail, kita memerlukan objek dari aliran. Kemudian, untuk membaca atau menulis ke fail, kita harus membuka fail tersebut. Kami telah memasukkan fail header fstream pada baris nombor-1 sehingga kami dapat mengakses kelas aliran.
Kami telah menyatakan myFile_Handler sebagai objek aliran dalam fungsi utama. Kita kemudian dapat menggunakan fungsi open () untuk membuat file kosong dan fungsi close () untuk menutup fail.
#sertakanmenggunakan ruang namaJam;
intutama()
{
ofstream myFile_Handler;
// Fail Dibuka
myFile_Handler.buka('Fail_1.txt');
// Fail Tutup
myFile_Handler.tutup();
kembali 0;
}
Sekarang, kami akan menyusun program dan memeriksa hasilnya. Seperti yang anda lihat di tetingkap output di bawah, fail File_1.txt dibuat setelah menjalankan program. Saiz fail adalah sifar kerana kami belum menulis kandungan dalam fail tersebut.
Contoh 2: Tulis ke Fail
Dalam program contoh sebelumnya, kami menunjukkan cara membuka fail dan cara menutup fail. Sekarang, kami akan menunjukkan kepada anda cara menulis sesuatu dalam fail.
Kami boleh menulis ke fail menggunakan operator penyisipan aliran, iaitu,<<. In this program, we have used the file handler and insertion operator to write two lines in the file. The insertion operator (<<) indicates that we are inserting the string into the output file stream object.
#sertakanmenggunakan ruang namaJam;
intutama()
{
ofstream myFile_Handler;
// Fail Dibuka
myFile_Handler.buka('Fail_1.txt');
// Tulis ke fail
myFile_Handler<< 'Ini adalah contoh fail ujian. ' <<endl;
myFile_Handler<< 'Ini adalah baris kedua fail. ' <<endl;
// Fail Tutup
myFile_Handler.tutup();
kembali 0;
}
Sekarang, kami akan menyusun program di atas dan melaksanakannya. Seperti yang anda lihat di bawah, kami berjaya menulis ke fail File_1.txt.
Contoh 3: Baca dari Fail
Dalam contoh sebelumnya, kami menunjukkan kepada anda cara menulis kandungan ke fail. Sekarang, mari baca kandungan dari fail yang kami buat dalam Contoh-2 dan paparkan kandungan pada peranti output standard, iaitu monitor.
Kami menggunakan fungsi getline () untuk membaca baris lengkap dari fail dan kemudian memberi isyarat untuk mencetak garis pada monitor.
#sertakan#sertakan
#sertakan
menggunakan ruang namaJam;
intutama()
{
ifstream myFile_Handler;
tali myLine;
// Fail Dibuka dalam Mod Baca
myFile_Handler.buka('Fail_1.txt');
sekiranya(myFile_Handler.ia terbuka())
{
// Terus membaca failnya
sementara(garis panduan(myFile_Handler, myLine))
{
// cetak garis pada output standard
kos <<myLine<<endl;
}
// Fail Tutup
myFile_Handler.tutup();
}
yang lain
{
kos << 'Tidak dapat membuka fail!';
}
kembali 0;
}
Sekarang, kami akan mencetak kandungan File_1.txt menggunakan arahan berikut: cat File_1.txt. Setelah kami menyusun dan melaksanakan program, jelas bahawa output sesuai dengan kandungan fail. Oleh itu, kami telah berjaya membaca fail tersebut dan mencetak kandungan fail tersebut ke monitor.
Contoh 4: Baca dan Tulis ke Fail
Sejauh ini, kami telah menunjukkan kepada anda cara membuka, membaca, menulis, dan menutup fail. Dalam C ++, kita juga dapat membaca dan menulis ke fail pada masa yang sama. Untuk membaca dan menulis ke fail, kita harus mendapatkan objek fstream dan membuka fail dalam mod ios :: in dan ios :: out.
Dalam contoh ini, pertama-tama kita menulis beberapa kandungan ke fail. Kemudian, kami membaca data dari fail dan mencetaknya ke monitor.
#sertakan#sertakan
#sertakan
menggunakan ruang namaJam;
intutama()
{
fstream myFile_Handler;
tali myLine;
// Fail Dibuka
myFile_Handler.buka('Fail_1.txt', ios::dalam |ios::keluar);
// Periksa sama ada fail telah dibuka
sekiranya(!myFile_Handler)
{
kos << 'Fail tidak dibuka!';
jalan keluar(1);
}
// Tulis ke fail
myFile_Handler<< '1. Ini adalah satu lagi contoh fail ujian. ' <<endl;
myFile_Handler<< '2. Ini adalah baris kedua fail. ' <<endl;
myFile_Handler.mencari(ios::mohon);
// Baca Fail
sekiranya(myFile_Handler.ia terbuka())
{
// Terus membaca failnya
sementara(garis panduan(myFile_Handler, myLine))
{
// cetak garis pada output standard
kos <<myLine<<endl;
}
// Fail Tutup
myFile_Handler.tutup();
}
yang lain
{
kos << 'Tidak dapat membuka fail!';
}
myFile_Handler.tutup();
kembali 0;
}
Sekarang, kami akan menyusun dan melaksanakan program tersebut.
Contoh 5: Baca dan Tulis ke Fail Binari
Dalam contoh ini, kita akan menyatakan kelas dan kemudian menulis objek ke fail binari. Untuk mempermudah contoh ini, kami telah menyatakan kelas Pekerja dengan emp_id pemboleh ubah awam. Kemudian, kami akan membaca fail binari dan mencetak output ke monitor.
#sertakan#sertakan
menggunakan ruang namaJam;
kelasPekerja
{
awam:
intemp_id;
};
intutama()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Pekerja empObj_W, empObj_R;
// Fail Dibuka
binOutFile_Handler.buka('pekerja.dat', ios::keluar |ios::binari);
// Periksa sama ada fail telah dibuka
sekiranya(!binOutFile_Handler)
{
kos << 'Fail tidak dibuka!';
jalan keluar(1);
}
// Permulaan empObj_W
empObj_W.emp_id = 1512;
// Tulis ke fail
binOutFile_Handler.menulis((char *) &empObj_W,saiz(Pekerja));
binOutFile_Handler.tutup();
sekiranya(!binOutFile_Handler.baik())
{
kos << 'Ralat berlaku semasa menulis fail binari!' <<endl;
jalan keluar(2);
}
// Sekarang, mari baca fail pekerja.dat
binInFile_Handler.buka('pekerja.dat', ios::dalam |ios::binari);
// Periksa sama ada fail telah dibuka
sekiranya(!binInFile_Handler)
{
kos << 'Fail tidak dibuka!';
jalan keluar(3);
}
// Baca kandungan fail binari
binInFile_Handler.membaca((char *) &empObj_R,saiz(Pekerja));
binInFile_Handler.tutup();
sekiranya(!binInFile_Handler.baik())
{
kos << 'Ralat berlaku semasa membaca fail binari!' <<endl;
jalan keluar(4);
}
// Cetak output empObj_R
kos << 'Perincian Pekerja:' <<endl;
kos << 'ID pekerja : ' <<empObj_R.emp_id <<endl;
kembali 0;
}
Kesimpulannya
Fail digunakan terutamanya untuk menyimpan data, dan memainkan peranan penting dalam pengaturcaraan dunia nyata. Dalam artikel ini, kami menunjukkan cara menggunakan pelbagai operasi fail dengan bahasa pengaturcaraan C ++ dengan menggunakan beberapa contoh. Selanjutnya, kami menunjukkan kepada anda cara membaca dan menulis data ke dalam fail teks dan fail binari.