Como se abre um ficheiro em C++?
quero abrir um ficheiro para ler, a forma C++. Preciso de ser capaz de o fazer por: [[3]}
arquivos de texto, que envolveria algum tipo de função de linha de leitura.
ficheiros binários, que forneceriam uma forma de ler os dados raw num buffer
char*
.
8 answers
Todos estes são adequados para texto e binário, embora nenhum tenha uma funcionalidade de leitura específica. O que você mais provavelmente faria em vez disso, nesse caso, é usar as classes de fluxo de fluxo (fstream.h) e usar os operadores de fluxo (>>) ou a função de leitura para ler/escrever blocos de texto:
int nsize = 10;
char *somedata;
ifstream myfile;
myfile.open("<path to file>");
myfile.read(somedata,nsize);
myfile.close();
Note que, se você estiver usando Visual Studio 2005 ou superior, o fstream tradicional pode não estar disponível (há uma nova implementação da Microsoft, que é ligeiramente diferente, mas realiza a mesma coisa).
ifstream
se apenas quiser ler (use um ofstream
para escrever, ou um fstream
para ambos).
Para abrir um ficheiro no modo de texto, faça o seguinte:
ifstream in("filename.ext", ios_base::in); // the in flag is optional
Para abrir um ficheiro em modo binário, basta adicionar a opção" binário".
ifstream in2("filename2.ext", ios_base::in | ios_base::binary );
ifstream.read()
função para ler um bloco de caracteres (em modo binário ou texto). Use o getline()
função (é global) para ler uma linha inteira.
Para abrir e ler uma linha de ficheiro de texto por linha, 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 ficheiro binário, é necessário declarar explicitamente que o formato de leitura no seu fluxo de entrada é binário, e ler a memória que não tem interpretação explícita usando a função de membro do fluxoread()
:
// 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ê vai precisar #include
o cabeçalho : <iostream>
#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......
}
#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;
}
Segue os passos,
- incluir ficheiros Header ou espaço de nome para aceder à classe de Ficheiros.
- Make File class object Depending on your IDE platform (I. E., CFile, QFile, fstream).
- Agora você pode facilmente encontrar esses métodos de classe para abrir/ler/fechar/getline ou de qualquer outro arquivo.
CFile/QFile/ifstream m_file; m_file.Open(path,Other parameter/mood to open file);
Para ler o ficheiro, tem de fazer buffer ou string para gravar os dados e pode passar essa variável no método read ().
#include <fstream>
ifstream infile;
infile.open(**file path**);
while(!infile.eof())
{
getline(infile,data);
}
infile.close();
Fstream é grande, mas eu vou um pouco mais fundo e contar-te sobre RAII.
O problema com um exemplo clássico é que você é forçado a fechar o arquivo por si mesmo, o que significa que você terá que dobrar sua arquitetura para esta necessidade. RAII faz uso da chamada de destruição automática em C++ para fechar o arquivo para você.
Update : parece que o std:: o fstream já implementa o RAII para que o código abaixo seja inútil. 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 pode usar esta classe no seu código assim:
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
Aprender como o rali funciona pode poupar-te dores de cabeça e alguns erros de gestão da memória.