Tässä artikkelissa aiomme näyttää sinulle kuinka lukea ja kirjoittaa tiedostoon C ++ -ohjelmointikielellä käyttämällä useita esimerkkejä. Ymmärtääksemme C ++ -tiedostooperaatioita, kuten lukemista ja kirjoittamista, meidän on ensin ymmärrettävä virran käsite C ++: ssa.
Mikä on Stream?
Virta on yksinkertaisesti datavirtaa tai merkkiä. Virtoja on kahdenlaisia: syöttövirrat ja lähtövirrat. Syöttövirtaa käytetään tietojen lukemiseen ulkoiselta syöttölaitteelta, kuten näppäimistöltä, kun taas lähtövirtaa käytetään tietojen kirjoittamiseen ulkoiselle tulostuslaitteelle, kuten näytölle. Tiedostoa voidaan pitää sekä tulo- että lähtölähteenä.
C ++: ssa käytämme virtaa lähettämään tai vastaanottamaan tietoja ulkoisesta lähteestä tai ulkoisesta lähteestä.
Voimme käyttää sisäänrakennettuja luokkia päästäksesi tulo-/lähtövirtaan, ts.
Tässä on C ++ -ohjelmointikielen stream -luokan hierarkia:
Cin- ja cout -objekteja käytetään tietojen lukemiseen näppäimistöltä ja tulosten näyttämiseen näytössä. Lisäksi ifstreamia, joka tarkoittaa syötetiedostovirtaa, käytetään datavirran lukemiseen tiedostosta ja ofstreamia, joka tarkoittaa tulostiedostovirtaa, käytetään datavirran kirjoittamiseen tiedostoon.
Iostram.h -tiedosto sisältää kaikki vaaditut vakiotulo-/tulostusvirraluokat C ++ -ohjelmointikielellä.
Esimerkkejä
Nyt kun ymmärrät streamien perusteet, keskustelemme seuraavista esimerkeistä, jotka auttavat sinua ymmärtämään paremmin tiedostojen toimintaa C ++: ssa:
- Esimerkki 1: Avaa ja sulje tiedosto
- Esimerkki 2: Kirjoita tiedostoon
- Esimerkki 3: Lue tiedostosta
- Esimerkki 4: Lue ja kirjoita tiedostoon
- Esimerkki 5: Lue ja kirjoita binääritiedostoon
Esimerkki 1: Avaa ja sulje tiedosto
Tässä esimerkkiohjelmassa näytämme, kuinka tiedosto avataan/luodaan ja miten tiedosto suljetaan C ++: ssa. Kuten alla olevasta ohjelmasta näet, olemme sisällyttäneet tiedostojen toimintoihin tarvittavan kirjaston.
Tiedoston avaamiseksi ja sulkemiseksi tarvitsemme ofstream -objektin. Sitten, jotta voimme lukea tai kirjoittaa tiedostoon, meidän on avattava tiedosto. Olemme sisällyttäneet fstream-otsikkotiedoston riville numero 1, jotta voimme käyttää offstream-luokkaa.
Olemme julistaneet myFile_Handlerin päävirran sisällä olevaksi virran objektiksi. Voimme sitten käyttää open () -toimintoa tyhjän tiedoston luomiseen ja close () -toimintoa tiedoston sulkemiseen.
#sisältääkäyttämällä nimiavaruustuntia;
inttärkein()
{
ofstream myFile_Handler;
// Tiedosto auki
myFile_Handler.avata(Tiedosto_1.txt);
// Tiedosto Sulje
myFile_Handler.kiinni();
palata 0;
}
Nyt kokoamme ohjelman ja tutkimme tuloksia. Kuten alla olevasta tulostusikkunasta näet, File_1.txt -tiedosto luotiin ohjelman suorittamisen jälkeen. Tiedoston koko on nolla, koska emme ole kirjoittaneet tiedostoon mitään sisältöä.
Esimerkki 2: Kirjoita tiedostoon
Edellisessä esimerkkiohjelmassa näytimme sinulle, kuinka voit avata tiedoston ja sulkea tiedoston. Nyt näytämme, kuinka kirjoittaa jotain tiedostoon.
Voimme kirjoittaa tiedostoon käyttämällä virran lisäysoperaattoria, ts.<<. 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.
#sisältääkäyttämällä nimiavaruustuntia;
inttärkein()
{
ofstream myFile_Handler;
// Tiedosto auki
myFile_Handler.avata(Tiedosto_1.txt);
// Kirjoita tiedostoon
myFile_Handler<< 'Tämä on esimerkkitestitiedosto. '' <<endl;
myFile_Handler<< 'Tämä on tiedoston toinen rivi. '' <<endl;
// Tiedosto Sulje
myFile_Handler.kiinni();
palata 0;
}
Nyt koomme yllä olevan ohjelman ja suoritamme sen. Kuten alla näet, olemme onnistuneesti kirjoittaneet tiedostoon File_1.txt.
Esimerkki 3: Lue tiedostosta
Aiemmissa esimerkeissä näytimme sinulle, miten voit kirjoittaa sisältöä tiedostoon. Nyt luetaan esimerkissä 2 luomamme tiedoston sisältö ja näytetään sisältö tavallisella tulostuslaitteella, eli näytöllä.
Käytämme getline () -toimintoa koko rivin lukemiseksi tiedostosta ja tulostamme sitten rivin näytöllä.
#sisältää#sisältää
#sisältää
käyttämällä nimiavaruustuntia;
inttärkein()
{
ifstream myFile_Handler;
merkkijono myLine;
// Tiedosto Avaa lukutilassa
myFile_Handler.avata(Tiedosto_1.txt);
jos(myFile_Handler.is_open())
{
// Jatka tiedoston lukemista
sillä aikaa(getline(myFile_Handler, myLine))
{
// tulosta viiva vakiotulosteeseen
kustannus <<Minun vuorosanani<<endl;
}
// Tiedosto Sulje
myFile_Handler.kiinni();
}
muu
{
kustannus << 'Tiedostoa ei voi avata!';
}
palata 0;
}
Tulostamme nyt tiedoston File_1.txt sisällön käyttämällä seuraavaa komentoa: cat File_1.txt. Kun olemme koonneet ja suorittaneet ohjelman, on selvää, että tulostus vastaa tiedoston sisältöä. Siksi olemme lukeneet tiedoston ja tulostaneet sen sisällön näyttöön.
Esimerkki 4: Lue ja kirjoita tiedostoon
Toistaiseksi olemme näyttäneet sinulle, kuinka voit avata, lukea, kirjoittaa ja sulkea tiedoston. C ++: ssa voimme myös lukea ja kirjoittaa tiedostoon samanaikaisesti. Jotta voimme lukea ja kirjoittaa tiedostoon, meidän on hankittava fstream -objekti ja avattava tiedosto ios :: in- ja ios :: out -tilassa.
Tässä esimerkissä kirjoitamme ensin jonkin verran sisältöä tiedostoon. Sitten luemme tiedoston tiedot ja tulostamme ne näyttöön.
#sisältää#sisältää
#sisältää
käyttämällä nimiavaruustuntia;
inttärkein()
{
fstream myFile_Handler;
merkkijono myLine;
// Tiedosto auki
myFile_Handler.avata(Tiedosto_1.txt, ios::sisään |ios::ulos);
// Tarkista, onko tiedosto avattu
jos(!myFile_Handler)
{
kustannus << 'Tiedosto ei avautunut!';
poistua(1);
}
// Kirjoita tiedostoon
myFile_Handler<< '' 1. Tämä on toinen testitiedosto. '' <<endl;
myFile_Handler<< '2. Tämä on tiedoston toinen rivi. '' <<endl;
myFile_Handler.hakea(ios::kerjätä);
// Lue tiedosto
jos(myFile_Handler.is_open())
{
// Jatka tiedoston lukemista
sillä aikaa(getline(myFile_Handler, myLine))
{
// tulosta viiva vakiotulosteeseen
kustannus <<Minun vuorosanani<<endl;
}
// Tiedosto Sulje
myFile_Handler.kiinni();
}
muu
{
kustannus << 'Tiedostoa ei voi avata!';
}
myFile_Handler.kiinni();
palata 0;
}
Nyt kokoamme ja suoritamme ohjelman.
Esimerkki 5: Lue ja kirjoita binääritiedostoon
Tässä esimerkissä aiomme julistaa luokan ja kirjoittaa sitten objektin binääritiedostoon. Tämän esimerkin yksinkertaistamiseksi olemme ilmoittaneet Employee -luokan julkisella muuttujalla emp_id. Sitten luemme binaaritiedoston ja tulostamme tuloksen monitorille.
#sisältää#sisältää
käyttämällä nimiavaruustuntia;
luokkaTyöntekijä
{
julkinen:
intemp_id;
};
inttärkein()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Työntekijä empObj_W, empObj_R;
// Tiedosto auki
binOutFile_Handler.avata('työntekijä.dat', ios::ulos |ios::binääri);
// Tarkista, onko tiedosto avattu
jos(!binOutFile_Handler)
{
kustannus << 'Tiedosto ei avautunut!';
poistua(1);
}
// Alusta empObj_W
empObj_W.emp_id = 1512;
// Kirjoita tiedostoon
binOutFile_Handler.kirjoittaa((hiiltyä *) &empObj_W,koko(Työntekijä));
binOutFile_Handler.kiinni();
jos(!binOutFile_Handler.hyvä())
{
kustannus << 'Virhe binaaritiedoston kirjoittamisen aikana!' <<endl;
poistua(2);
}
// Luetaan nyt työntekijä.dat -tiedosto
binInFile_Handler.avata('työntekijä.dat', ios::sisään |ios::binääri);
// Tarkista, onko tiedosto avattu
jos(!binInFile_Handler)
{
kustannus << 'Tiedosto ei avautunut!';
poistua(3);
}
// Lue binaaritiedoston sisältö
binInFile_Handler.lukea((hiiltyä *) &empObj_R,koko(Työntekijä));
binInFile_Handler.kiinni();
jos(!binInFile_Handler.hyvä())
{
kustannus << 'Virhe binääritiedoston lukemisen aikana!' <<endl;
poistua(4);
}
// Tulosta empObj_R: n tulos
kustannus << 'Työntekijän tiedot:' <<endl;
kustannus << 'Henkilöstökortti : ' <<empObj_R.emp_id <<endl;
palata 0;
}
Johtopäätös
Tiedostoja käytetään pääasiassa tietojen tallentamiseen, ja niillä on tärkeä rooli todellisessa ohjelmoinnissa. Tässä artikkelissa esittelimme sinulle kuinka käyttää erilaisia tiedostooperaatioita C ++ -ohjelmointikielellä käsittelemällä useita esimerkkejä. Lisäksi näytimme sinulle, miten voit lukea ja kirjoittaa tietoja sekä tekstitiedostoihin että binaaritiedostoihin.