Ik wil een bestand openen om te lezen, op de C++-manier. Ik moet het kunnen doen voor:
-
tekstbestanden, waarvoor een soort leesregelfunctie nodig is.
-
binaire bestanden, waarmee onbewerkte gegevens in een
char*-buffer kunnen worden gelezen.
Antwoord 1, autoriteit 100%
Er zijn drie manieren om dit te doen, afhankelijk van uw behoeften. Je zou de old-school C-manier kunnen gebruiken en fopen/fread/fclosekunnen bellen, of je zou de C++ fstream-faciliteiten kunnen gebruiken (ifstream/ofstream), of als u MFC gebruikt, gebruikt u de klasse CFile, die functies biedt om daadwerkelijke bestandsbewerkingen uit te voeren.
Al deze zijn geschikt voor zowel tekst als binair, hoewel geen enkele een specifieke leesregel-functionaliteit heeft. Wat u in dat geval waarschijnlijk zou doen, is de fstream-klassen (fstream.h) gebruiken en de stream-operators (<< en >>) of de leesfunctie gebruiken om tekstblokken te lezen/schrijven:
int nsize = 10;
std::vector<char> somedata(nsize);
ifstream myfile;
myfile.open("<path to file>");
myfile.read(somedata.data(), nsize);
myfile.close();
Houd er rekening mee dat, als u Visual Studio 2005 of hoger gebruikt, traditionele fstream mogelijk niet beschikbaar is (er is een nieuwe Microsoft-implementatie, die iets anders is, maar hetzelfde doet).
Antwoord 2, autoriteit 98%
U moet een ifstreamgebruiken als je wilt alleen lezen (gebruik een ofstreamom te schrijven, of een fstreamvoor beide).
Als u een bestand in tekstmodus wilt openen, doet u het volgende:
ifstream in("filename.ext", ios_base::in); // the in flag is optional
Om een bestand in binaire modus te openen, hoeft u alleen maar de “binaire” vlag toe te voegen.
ifstream in2("filename2.ext", ios_base::in | ios_base::binary );
Gebruik de ifstream.read()functie om een blok karakters te lezen (in binaire of tekstmodus). Gebruik de functie getline()(het is globaal) om een hele regel te lezen.
Antwoord 3, autoriteit 18%
Om een tekstbestandregel per regel te openen en te lezen, kunt u het volgende gebruiken:
// define your file name
string file_name = "data.txt";
// attach an input stream to the wanted file
ifstream input_stream(file_name);
// check stream status
if (!input_stream) cerr << "Can't open input file!";
// file contents
vector<string> text;
// one line
string line;
// extract all the text from the input file
while (getline(input_stream, line)) {
// store each line in the vector
text.push_back(line);
}
Om een binair bestand te openen en te lezen, moet u het leesformaat in uw invoerstroom expliciet als binair declareren en geheugen lezen dat geen expliciete interpretatie heeft met behulp van de streamlidfunctie read():
// define your file name
string file_name = "binary_data.bin";
// attach an input stream to the wanted file
ifstream input_stream(file_name, ios::binary);
// check stream status
if (!input_stream) cerr << "Can't open input file!";
// use function that explicitly specifies the amount of block memory read
int memory_size = 10;
// allocate 10 bytes of memory on heap
char* dynamic_buffer = new char[memory_size];
// read 10 bytes and store in dynamic_buffer
file_name.read(dynamic_buffer, memory_size);
Als je dit doet, moet je #includede header : <iostream>
Antwoord 4, autoriteit 9%
#include <iostream>
#include <fstream>
using namespace std;
int main () {
ofstream file;
file.open ("codebind.txt");
file << "Please writr this text to a file.\n this text is written using C++\n";
file.close();
return 0;
}
Antwoord 5
#include <iostream>
#include <fstream>
using namespace std;
void main()
{
ifstream in_stream; // fstream command to initiate "in_stream" as a command.
char filename[31]; // variable for "filename".
cout << "Enter file name to open :: "; // asks user for input for "filename".
cin.getline(filename, 30); // this gets the line from input for "filename".
in_stream.open(filename); // this in_stream (fstream) the "filename" to open.
if (in_stream.fail())
{
cout << "Could not open file to read.""\n"; // if the open file fails.
return;
}
//.....the rest of the text goes beneath......
}
Antwoord 6
Volg de stappen,
- Voeg header-bestanden of naamruimte toe om toegang te krijgen tot de bestandsklasse.
- Maak een bestandsklasse-object Afhankelijk van uw IDE-platform (d.w.z.
CFile,QFile,fstream). - Nu kunt u gemakkelijk deze klassemethoden vinden om te openen / lezen / sluiten / Getline of anders van een bestand.
CFile/QFile/ifstream m_file; m_file.Open(path,Other parameter/mood to open file);
Voor het lezen van bestand moet u buffer of string maken om gegevens op te slaan en u kunt die variabele in lees () methode doorgeven.
Antwoord 7
**#include<fstream> //to use file
#include<string> //to use getline
using namespace std;
int main(){
ifstream file;
string str;
file.open("path the file" , ios::binary | ios::in);
while(true){
getline(file , str);
if(file.fail())
break;
cout<<str;
}
}**
Antwoord 8
#include <fstream>
ifstream infile;
infile.open(**file path**);
while(!infile.eof())
{
getline(infile,data);
}
infile.close();
Antwoord 9
Fstream is geweldig, maar ik zal een beetje dieper gaan en je vertellen over raii .
Het probleem met een klassiek voorbeeld is dat u gedwongen bent om het bestand zelf te sluiten, wat betekent dat u uw architectuur moet buigen naar deze behoefte. RAII maakt gebruik van de automatische destructor-oproep in C++ om het bestand voor u te sluiten.
update : lijkt dat std :: fstream al implementeert RAII, zodat de onderstaande code nutteloos is. Ik bewaar het hier voor het nageslacht en als een voorbeeld van Raii.
class FileOpener
{
public:
FileOpener(std::fstream& file, const char* fileName): m_file(file)
{
m_file.open(fileName);
}
~FileOpeneer()
{
file.close();
}
private:
std::fstream& m_file;
};
Je kunt deze klasse nu als volgt in je code gebruiken:
int nsize = 10;
char *somedata;
ifstream myfile;
FileOpener opener(myfile, "<path to file>");
myfile.read(somedata,nsize);
// myfile is closed automatically when opener destructor is called
Als u leert hoe RAII werkt, kunt u hoofdpijn en een aantal grote fouten in geheugenbeheer besparen.