Domanda

Voglio aprire un file per la lettura, in modo C++.Devo essere in grado di farlo per:

  • file di testo, che implicherebbero una sorta di funzione di riga di lettura.

  • file binari, che fornirebbero un modo per leggere i dati grezzi in un file char* respingente.

È stato utile?

Soluzione

Esistono tre modi per farlo, a seconda delle tue esigenze.Potresti usare il metodo C della vecchia scuola e chiamare fopen/fread/fclose, oppure potresti usare le strutture fstream C++ (ifstream/ofstream), o se stai usando MFC, usare la classe CFile, che fornisce funzioni per realizzare effettive operazioni sui file.

Tutti questi sono adatti sia per il testo che per il binario, sebbene nessuno abbia una funzionalità readline specifica.Ciò che molto probabilmente faresti invece in questo caso è utilizzare le classi fstream (fstream.h) e utilizzare gli operatori stream (<< e >>) o la funzione read per leggere/scrivere blocchi di testo:

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

Tieni presente che, se utilizzi Visual Studio 2005 o versioni successive, fstream tradizionale potrebbe non essere disponibile (esiste una nuova implementazione Microsoft, che è leggermente diversa, ma realizza la stessa cosa).

Altri suggerimenti

È necessario utilizzare un ifstream se vuoi solo leggere (usa un ofstream scrivere, o un fstream per entrambi).

Per aprire un file in modalità testo, procedere come segue:

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

Per aprire un file in modalità binaria è sufficiente aggiungere il flag "binario".

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

Usa il ifstream.read() funzione per leggere un blocco di caratteri (in modalità binaria o testo).Usa il getline() funzione (è globale) per leggere un'intera riga.

Per aprire e leggere un file di testo riga per riga, è possibile utilizzare quanto segue:

// 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);
}

Per aprire e leggere un file binario è necessario dichiarare esplicitamente che il formato di lettura nel flusso di input è binario e leggere la memoria che non ha un'interpretazione esplicita utilizzando la funzione membro del flusso 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);

Quando lo fai, dovrai farlo #include l'intestazione: <iostream>

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

Segui i passi,

  1. Includi file di intestazione o spazio dei nomi per accedere alla classe File.
  2. Crea oggetto di classe file a seconda della piattaforma IDE (cioè, cfile, qfile, fstream).
  3. Ora puoi trovare facilmente i metodi della classe per aprire/leggere/chiudere/getline o altro di qualsiasi file.
CFile/QFile/ifstream m_file;
m_file.Open(path,Other parameter/mood to open file);

Per leggere il file devi creare un buffer o una stringa per salvare i dati e puoi passare quella variabile nel metodo read().

**#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;
}
}**
#include <fstream>

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

fstream sono fantastici ma andrò un po' più in profondità e te ne parlerò RAII.

Il problema con un esempio classico è che sei costretto a chiudere il file da solo, il che significa che dovrai piegare la tua architettura a questa esigenza.RAII utilizza la chiamata automatica al distruttore in C++ per chiudere il file.

Aggiornamento:sembra che std::fstream implementi già RAII quindi il codice seguente è inutile.Lo terrò qui per i posteri e come esempio della 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;
};

Ora puoi utilizzare questa classe nel tuo codice in questo modo:

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

Imparare come funziona RAII può farti risparmiare qualche grattacapo e alcuni importanti bug di gestione della memoria.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top