Hoe kan jy 'n lêer in C ++ oop te maak?

Question

Ek wil 'n lêer oop te maak om te lees, die C ++ manier. Ek moet in staat wees om dit te doen vir:

• teks lêers, wat 'n soort van lees lynfunksie sou betrek.

• binêre lêers, wat 'n manier om rou data te lees in 'n char* buffer sal verskaf.

Answer 1

Daar is drie maniere om dit te doen, afhangende van jou behoeftes. Jy kan die ou-skool C manier gebruik en noem fopen / fread / fclose, of jy kan gebruik maak van die C ++ fstream fasiliteite (ifstream / ofstream), of as jy die gebruik van MFC, gebruik die CFile klas, wat funksies bied werklike tot stand te bring lêer operasies.

Al hierdie is geskik vir beide teks en binêre, maar niemand het 'n spesifieke read line funksionaliteit. Wat jy waarskynlik doen in plaas in so 'n geval is die gebruik van die fstream klasse (fstream.h) en gebruik die stroom operateurs (<< en >>) of die lees funksie om te lees / skryf blokke teks:

int nsize = 10;
char *somedata;
ifstream myfile;
myfile.open("<path to file>");
myfile.read(somedata,nsize);
myfile.close();

Let daarop dat, indien jy met behulp van Visual Studio 2005 of hoër, tradisionele fstream mag nie beskikbaar wees (daar is 'n nuwe Microsoft implementering, wat is effens anders, maar accomplishes dieselfde ding).

Answer 2

Jy moet 'n ifstream as jy net wil om te lees (gebruik gebruik 'n ofstream te skryf, of 'n fstream vir beide).

Om 'n lêer in teks af oop te maak, doen die volgende:

ifstream in("filename.ext", ios_base::in); // the in flag is optional

Om 'n lêer in binêre modus oop te maak, net wat jy nodig het om die "binêre" vlag voeg.

ifstream in2("filename2.ext", ios_base::in | ios_base::binary ); 

Gebruik die ifstream.read() funksie om 'n blok van karakters te lees (in binêre of teks af). Gebruik die getline() funksie (dis globale) om 'n hele lyn lees.

Answer 3

Om oop te maak en te lees van 'n teks lêer lyn per lyn, kan jy gebruik maak van die volgende:

// 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 oop te maak en te lees 'n binêre lêer wat jy nodig het om uitdruklik verklaar die lees-formaat in jou inset stroom binêre te wees, en lees geheue wat geen eksplisiete interpretasie het met behulp van stroom lid funksie 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);

As dit te doen wat jy nodig het om #include die kop: <iostream>

Answer 4

#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;
}

Answer 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......
}

Answer 6

Volg die stappe,

1. Sluit Selected lêers of naam ruimte om toegang te verkry lêer klas.
2. Maak lêer objekklas Afhangende van jou IDE platform (d.w.z, CFile, qfile, fstream).
3. Nou kan jy maklik vind dat klas metodes om / gelees / naby / getline of anders van 'n lêer oop te maak.

CFile/QFile/ifstream m_file;
m_file.Open(path,Other parameter/mood to open file);

Vir die lees van lêer moet jy buffer of string maak om data te stoor en jy kan dit veranderlike slaag in Read () metode.

Answer 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;
}
}**

Answer 8

#include <fstream>

ifstream infile;
infile.open(**file path**);
while(!infile.eof())
{
   getline(infile,data);
}
infile.close();

Answer 9

fstream is groot, maar ek sal 'n bietjie dieper gaan en jy vertel oor RAII .

Die probleem met 'n klassieke voorbeeld is dat jy gedwing word om die lêer te sluit deur jouself, wat beteken dat jy sal moet jou argitektuur buig om hierdie behoefte. RAII maak gebruik van die outomatiese destructor oproep in C ++ om die lêer te sluit vir jou.

Update : blyk dat st :: fstream reeds RAII implemente so die kode hieronder is nutteloos. Ek sal dit hier hou vir die nageslag en as 'n 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;
};

Jy kan nou gebruik hierdie klas in jou kode soos volg:

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

Leer hoe RAII werke wat jy kan red 'n paar hoofpyne en 'n paar groot geheue bestuur foute.