Pergunta

Gostaria de abrir um arquivo para leitura, o C++ forma.Eu preciso ser capaz de fazê-lo para:

  • arquivos de texto, o que envolveria algum tipo de leitura função de linha.

  • arquivos binários, que iria fornecer um caminho para a leitura de dados brutos em uma char* buffer.

Foi útil?

Solução

Existem três maneiras de fazer isso, dependendo de suas necessidades.Você pode usar a velha escola-C forma e chamada fopen/fread/fclose, ou você pode usar o C++ fstream instalações (ifstream/ofstream), ou se você estiver usando o MFC, use a classe CFile, que fornece funções para realizar real as operações de arquivo.

Todos estes são adequados para texto e binário, embora nenhum tenha um específico readline funcionalidade.O que você provavelmente vai fazer em vez disso, nesse caso, é usar o fstream classes (fstream.h) e utilizar o fluxo de operadores (<< e >>) ou a função de leitura para leitura/gravação de blocos de texto:

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

Observe que, se você estiver usando o Visual Studio 2005 ou superior, tradicional fstream podem não estar disponíveis (há uma nova implementação da Microsoft, que é um pouco diferente, mas faz a mesma coisa).

Outras dicas

Você precisa usar um ifstream se você só quer ler (use um ofstream para escrever, ou um fstream para ambos).

Para abrir um arquivo em modo texto, faça o seguinte:

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

Para abrir um arquivo no modo binário, você só precisa adicionar o "binário" bandeira".

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

Use o ifstream.read() função para ler um bloco de caracteres (em binário ou em modo texto).Use o getline() função (global) para ler uma linha inteira.

Para abrir e ler um arquivo de texto linha por linha, você pode usar o seguinte:

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

Para abrir e ler um arquivo binário que você precisa declarar explicitamente o formato de leitura em seu fluxo de entrada binário, e leitura de memória que não tem explícita a interpretação usando o fluxo de função de membro 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);

Ao fazer isso você precisará #include o cabeçalho : <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......
}

Siga os passos,

  1. Incluir arquivos de Cabeçalho ou de espaço de nome para acessar o Arquivo de classe.
  2. Verifique o Arquivo de classe de objecto, Dependendo de sua IDE ( plataforma de eu.e, CFile,QFile,fstream).
  3. Agora você pode facilmente encontrar que os métodos de classe para abrir/ler/fechar/getline ou outra coisa qualquer arquivo.
CFile/QFile/ifstream m_file;
m_file.Open(path,Other parameter/mood to open file);

Para a leitura de arquivos que você tem para fazer buffer de cadeia ou para salvar os dados e você pode passar essa variável no método 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 são grandes, mas eu vou ir um pouco mais fundo e dizer a você sobre RAII.

O problema com um exemplo clássico é que você é forçado a fechar o arquivo por si próprio, o que significa que você vai ter que dobrar sua arquitetura a esta necessidade.RAII faz uso do automáticas processo de destruição chamada em C++ para fechar o arquivo para você.

Atualização:parece que a std::fstream já implementa RAII assim, o código abaixo é inútil.Eu vou mantê-lo aqui para a posteridade e como um exemplo de 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;
};

Agora você pode utilizar esta classe em seu código como este:

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

A aprendizagem como RAII obras pode poupar algumas dores de cabeça e alguns dos principais memória de gerenciamento de bugs.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top