Kuinka lukea ja kirjoittaa tiedostoon C ++: ssa

How Read Write File C

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.