En aquest article, us mostrarem com llegir i escriure en un fitxer en el llenguatge de programació C ++ mitjançant diversos exemples. Per entendre les operacions de fitxers C ++ com llegir i escriure, primer hem d’entendre el concepte d’un flux a C ++.
Què és un flux?
Un flux és simplement un flux de dades o caràcters. Hi ha dos tipus de fluxos: fluxos d’entrada i fluxos de sortida. Un flux d’entrada s’utilitza per llegir les dades d’un dispositiu d’entrada extern, com ara un teclat, mentre que un flux de sortida s’utilitza per escriure dades al dispositiu de sortida extern, com ara un monitor. Un fitxer es pot considerar tant com una font d’entrada com de sortida.
A C ++, fem servir un flux per enviar o rebre dades a o des d’una font externa.
Podem utilitzar classes integrades per accedir a un flux d’entrada / sortida, és a dir, iOS.
Aquí teniu la jerarquia de classes de flux del llenguatge de programació C ++:
Els objectes cin i cout s’utilitzen per llegir les dades del teclat i per mostrar la sortida al monitor, respectivament. A més, ifstream, que significa flux de fitxers d’entrada, s’utilitza per llegir un flux de dades d’un fitxer i ofstream, que significa flux de fitxers de sortida, s’utilitza per escriure un flux de dades a un fitxer.
El fitxer iostram.h conté totes les classes de flux d’entrada / sortida estàndard necessàries en el llenguatge de programació C ++.
Exemples
Ara que enteneu els conceptes bàsics dels fluxos, parlarem dels exemples següents per ajudar-vos a comprendre millor les operacions de fitxers en C ++:
- Exemple 1: obriu i tanqueu un fitxer
- Exemple 2: escriure a un fitxer
- Exemple 3: llegir des d'un fitxer
- Exemple 4: llegir i escriure en un fitxer
- Exemple 5: llegir i escriure en un fitxer binari
Exemple 1: obriu i tanqueu un fitxer
En aquest programa d’exemple, demostrarem com obrir / crear un fitxer i com tancar-lo a C ++. Com podeu veure al programa següent, hem inclòs la biblioteca necessària per a les operacions de fitxers.
Per obrir i tancar un fitxer, necessitem un objecte ofstream. Després, per llegir o escriure en un fitxer, hem d’obrir-lo. Hem inclòs el fitxer de capçalera fstream a la línia número 1 perquè puguem accedir a la classe ofstream.
Hem declarat un myFile_Handler com a objecte ofstream dins de la funció principal. A continuació, podem utilitzar la funció open () per crear un fitxer buit i la funció close () per tancar el fitxer.
#incloureutilitzant espai de nomshores;
intprincipal()
{
ofstream myFile_Handler;
// Arxiu obert
myFile_Handler.obert('Fitxer_1.txt');
// Tancar fitxer
myFile_Handler.Tanca();
tornar 0;
}
Ara, recopilarem el programa i examinarem la sortida. Com podeu veure a la finestra de sortida següent, el fitxer File_1.txt es va crear després d’executar el programa. La mida del fitxer és zero ja que no hem escrit cap contingut al fitxer.
Exemple 2: escriure a un fitxer
A l'exemple de programa anterior, us vam mostrar com obrir un fitxer i com tancar-lo. Ara, us mostrarem com escriure alguna cosa en un fitxer.
Podem escriure a un fitxer mitjançant l’operador d’inserció de flux, és a dir,<<. 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.
#incloureutilitzant espai de nomshores;
intprincipal()
{
ofstream myFile_Handler;
// Arxiu obert
myFile_Handler.obert('Fitxer_1.txt');
// Escriviu al fitxer
myFile_Handler<< 'Aquest és un exemple de fitxer de prova. ' <<endl;
myFile_Handler<< 'Aquesta és la segona línia del fitxer. ' <<endl;
// Tancar fitxer
myFile_Handler.Tanca();
tornar 0;
}
Ara, compilarem el programa anterior i l'executarem. Com podeu veure a continuació, hem escrit correctament al fitxer File_1.txt.
Exemple 3: llegir des d'un fitxer
En els exemples anteriors, us vam mostrar com escriure contingut en un fitxer. Ara, llegim el contingut del fitxer que vam crear a l’exemple 2 i mostrem el contingut al dispositiu de sortida estàndard, és a dir, al monitor.
Utilitzem la funció getline () per llegir la línia completa del fitxer i, a continuació, per imprimir la línia al monitor.
#incloure#incloure
#incloure
utilitzant espai de nomshores;
intprincipal()
{
ifstream myFile_Handler;
string myLine;
// Arxiu obert en mode de lectura
myFile_Handler.obert('Fitxer_1.txt');
si(myFile_Handler.està_obert())
{
// Continueu llegint el fitxer
mentre(getline(myFile_Handler, myLine))
{
// imprimeix la línia a la sortida estàndard
cost <<myLine<<endl;
}
// Tancar fitxer
myFile_Handler.Tanca();
}
en cas contrari
{
cost << 'No s'ha pogut obrir el fitxer.';
}
tornar 0;
}
Ara, imprimirem el contingut de File_1.txt mitjançant l'ordre següent: cat File_1.txt. Un cop compilem i executem el programa, queda clar que la sortida coincideix amb el contingut del fitxer. Per tant, hem llegit correctament el fitxer i hem imprès el contingut del fitxer al monitor.
Exemple 4: llegir i escriure en un fitxer
Fins ara, us hem mostrat com obrir, llegir, escriure i tancar un fitxer. A C ++, també podem llegir i escriure en un fitxer alhora. Tant per llegir com per escriure en un fitxer, hem d'obtenir un objecte fstream i obrir el fitxer en mode ios :: in ios :: out.
En aquest exemple, primer escrivim contingut al fitxer. A continuació, llegim les dades del fitxer i les imprimim al monitor.
#incloure#incloure
#incloure
utilitzant espai de nomshores;
intprincipal()
{
fstream myFile_Handler;
string myLine;
// Arxiu obert
myFile_Handler.obert('Fitxer_1.txt', is::dins |is::fora);
// Comproveu si el fitxer s'ha obert
si(!myFile_Handler)
{
cost << 'El fitxer no s'ha obert!';
sortir(1);
}
// Escriviu al fitxer
myFile_Handler<< «1. Aquest és un altre fitxer de prova de mostra. ' <<endl;
myFile_Handler<< '2. Aquesta és la segona línia del fitxer. ' <<endl;
myFile_Handler.seekg(is::suplica);
// Llegiu el fitxer
si(myFile_Handler.està_obert())
{
// Continueu llegint el fitxer
mentre(getline(myFile_Handler, myLine))
{
// imprimeix la línia a la sortida estàndard
cost <<myLine<<endl;
}
// Tancar fitxer
myFile_Handler.Tanca();
}
en cas contrari
{
cost << 'No s'ha pogut obrir el fitxer.';
}
myFile_Handler.Tanca();
tornar 0;
}
Ara, compilarem i executarem el programa.
Exemple 5: llegir i escriure en un fitxer binari
En aquest exemple, declararem una classe i després escriurem l'objecte a un fitxer binari. Per simplificar aquest exemple, hem declarat la classe Employee amb una variable pública emp_id. A continuació, llegirem el fitxer binari i imprimirem la sortida al monitor.
#incloure#incloure
utilitzant espai de nomshores;
classeEmpleat
{
públic:
intemp_id;
};
intprincipal()
{
binOutFile_Handler ofstream;
ifstream binInFile_Handler;
Empleat empObj_W, empObj_R;
// Arxiu obert
binOutFile_Handler.obert('empleat.dat', is::fora |is::binari);
// Comproveu si el fitxer s'ha obert
si(!binOutFile_Handler)
{
cost << 'El fitxer no s'ha obert!';
sortir(1);
}
// Inicialitzar empObj_W
empObj_W.emp_id = 1512;
// Escriviu al fitxer
binOutFile_Handler.escriure((char *) &empObj_W,mida de(Empleat));
binOutFile_Handler.Tanca();
si(!binOutFile_Handler.bé())
{
cost << 'S'ha produït un error en escriure el fitxer binari.' <<endl;
sortir(2);
}
// Ara, llegim el fitxer employee.dat
binInFile_Handler.obert('empleat.dat', is::dins |is::binari);
// Comproveu si el fitxer s'ha obert
si(!binInFile_Handler)
{
cost << 'El fitxer no s'ha obert!';
sortir(3);
}
// Llegiu el contingut del fitxer binari
binInFile_Handler.llegir((char *) &empObj_R,mida de(Empleat));
binInFile_Handler.Tanca();
si(!binInFile_Handler.bé())
{
cost << 'S'ha produït un error durant la lectura del fitxer binari.' <<endl;
sortir(4);
}
// Imprimiu la sortida de empObj_R
cost << 'Dades de l'empleat:' <<endl;
cost << 'Identificador d'empleat:' <<empObj_R.emp_id <<endl;
tornar 0;
}
Conclusió
Els fitxers s’utilitzen principalment per emmagatzemar les dades i tenen un paper important en la programació del món real. En aquest article, us hem mostrat com utilitzar diverses operacions de fitxers amb el llenguatge de programació C ++ mitjançant diversos exemples. A més, us vam mostrar com llegir i escriure dades tant en fitxers de text com en fitxers binaris.