Como usar C ++ FStream

O fStream termo significa fluxo de arquivos. Stream refere -se a uma sequência de caracteres que se movem do disco para o programa C ++ ou do programa C+ para o disco. Mover caracteres de um arquivo no disco para o programa está inserindo. Mover caracteres do programa para um arquivo no disco está emitindo. A abreviada de fluxo de entrada de entrada como Ifstream é estruturada pela classe de modelo, Basic_ifstream. Abreviado com o arquivo de saída de saída, OfStream é estruturado pela classe de modelo, Basic_Ofstream.

É possível que a entrada e saída ocorra em uma sessão. Isso é possível pelo modelo de classe, Basic_fstream. Agora, o FStream é sinônimo de Basic_fstream. FStream, que ainda é básico_fstream, usa Basic_ifstream e Ofstream para operar.

Para fazer a entrada sozinha, faça a saída sozinha ou ambos em uma sessão, basta iniciar o programa C ++ com o seguinte inclui e invocações de namespace:

#incluir
#incluir
usando namespace std;

Este tutorial possui quatro seções principais: abrindo e fechamento de um fluxo de arquivo, fluxo de arquivo de saída, anexando, fluxo de arquivos de entrada e edição de um arquivo. Editar um arquivo significa inserção e saída de um fluxo.

Conteúdo do artigo

• Abrindo e fechando um fluxo de arquivo
• Operação de fluxo de arquivo de saída
• Anexando os personagens a um arquivo
• Operação de fluxo de arquivos de entrada
• Lendo o arquivo inteiro com uma função
• Leitura de linha por linha
• Buscando no arquivo
• Função Tellg ()

Abrindo e fechando um fluxo de arquivo

Antes que um fluxo possa ser aberto, um objeto de fluxo deve ser criado. Abrir um fluxo significa estabelecer um canal entre o programa C ++ e o arquivo no disco. Isso é realizado através do qual a sequência de caracteres se moverá para o arquivo; ou através do qual a sequência de caracteres deixará o arquivo e chegará ao programa; ou através do qual os personagens se moverão de um lado para o outro.

Um fluxo é aberto apenas para escrever (saída), leitura (entrada) ou leitura e escrita. Também pode ser aberto por outros motivos.

Antes de abrir um fluxo, o objeto de fluxo deve ser construído. A maneira mais simples de expressá -lo é a seguinte na função c ++ main ():

fStream STRM;

Agora, com o objeto STRM, as funções de membro do FStream, Open () e Close () podem ser usadas, precedindo cada um com o operador de pontos. A declaração a seguir pode ser usada para abrir um Fream para leitura:

void aberto ("PATH/TO/e/O FILE", iOS_BASE :: in);

A função de membro open () retorna vazio.

Com o objeto de fluxo, a declaração seria:

strm.abrir("./myfile ", ios_base :: in);

Como a função de membro do Open () retorna, para saber se o arquivo no disco foi aberto com sucesso, use a função do membro:

bool is_open () const;

Ele retorna zero para false se o arquivo não foi aberto e 1 para verdadeiro se o arquivo aberto. Agora nosso programa se parece com isso até agora:

#incluir
#incluir
usando namespace std;
int main ()
fStream STRM;
strm.abrir("./myfile ", ios_base :: in);
if (strm.está aberto())
cout << "Open success" << endl;

outro
cout << "Open failed" << endl;
retornar 1;

retornar 0;

Para abrir um arquivo para escrever, use este sinalizador:

strm.aberto ("path/to/e/o/file", ios_base :: out);

ios_base :: in significa aberto para leitura e iOS_BASE :: Out significa aberto para escrever. Para abrir um arquivo para ler e escrever, use:

strm.aberto ("path/to/e/o/file", ios_base :: in | ios_base :: out);

Nota: A presença de “iOS_BASE :: in | ios_base :: Out ”, que usa lógico ou para combinar ambos os sinalizadores como um único argumento para a função.

Fechar um fluxo significa fechar o canal através do qual os dados podem ser enviados de um lado para o outro entre o programa e o arquivo. Não há mais dado pode ser enviado em qualquer direção usando esse canal. Fechar o fluxo não está fechando o objeto de fluxo. O mesmo fluxo ainda pode ser usado para abrir um novo canal, que deve ser fechado após o uso na transmissão de dados. Torne o hábito de fechar qualquer fluxo de arquivo, depois de ser aberto. Quando um fluxo é fechado, quaisquer dados na memória que deveriam estar no arquivo são enviados para o arquivo antes de realmente fechar. O protótipo da função do membro para fechar o Fream é:

vazio close ();

Retorna vazio, infelizmente. Então, para saber se o fechamento foi bem -sucedido, use a função do membro:

bool is_open () const;

Se o fechamento fosse bem -sucedido, isso retornaria zero, o que significa que o fluxo não está mais aberto. Se o fechamento não tivesse êxito, ele retornaria 1 e significa que o fluxo não poderia ser fechado.

Operação de fluxo de arquivo de saída

Agora, demonstraremos a abertura de um arquivo e dando a ele um novo conteúdo de dados. Para abrir um fluxo de saída com fsream, basta usar iOS_BASE :: Out Sozinho na função de membro Open (). O programa a seguir abre um arquivo e envia o conteúdo de uma string a ele:

#incluir
#incluir
usando namespace std;
int main ()
fStream STRM;
strm.aberto ("doc1.txt ", ios_base :: out);
se (!strm.está aberto())
cout << "File could not be opened!" << endl;
retornar 1;

char str [] = "A: Esta é a primeira linha.\ n "
"B: Esta é a segunda linha.\ n "
"C: Esta é a terceira linha.\ n ";
strm << str;
strm.fechar();
if (strm.está aberto())
cout << "Stream could not close!" << endl;
retornar 1;

cout << "Success, check file" << endl;
retornar 0;

O nome do arquivo é doc1.O txt pode incluir um caminho completo ou um caminho relativo. O novo conteúdo é identificado pelo STR no programa. No final do programa, o conteúdo da string teria sido inserido no fluxo e, portanto, o arquivo com a instrução:

strm << str;

Cout é um objeto de saída padrão e normalmente é usado para o console. Ele usa o operador de extração, << . O operador de extração também é usado com fluxos de arquivo. O objeto de fluxo de arquivos aqui é strm. O caractere '\ n' no final de cada cotação acima é garantir que a próxima linha apareça abaixo no arquivo de saída:

Em vez de enviar texto para o arquivo com o operador de inserção, a função Write () pode ser usada. O código a seguir ilustra o seguinte:

BASIC_OSTREAM & WRITE (const char_type* s, streamsize n)

Aqui está o código completo com a função de gravação usada:

#incluir
#incluir
#incluir
usando namespace std;
int main ()
fStream STRM;
strm.aberto ("doc2.txt ", ios_base :: out);
se (!strm.está aberto())
cout << "File could not be opened!" << endl;
retornar 1;

char str [] = "A: Esta é a primeira linha.\ n "
"B: Esta é a segunda linha.\ n "
"C: Esta é a terceira linha.\ n ";
strm.escreva (str, strlen (str));
strm.fechar();
if (strm.está aberto())
cout << "Stream could not close!" << endl;
retornar 1;

retornar 0;

O primeiro argumento da função write () é o identificador da matriz de caracteres. O segundo argumento é o número de caracteres (sem \ 0) na matriz.

Anexando caracteres a um arquivo

Para anexar texto a um arquivo, use "iOS_Base :: App" sozinho, em vez de "iOS_BASE: OUT" na função de membro open (). Ainda assim, use o operador de inserção, <<, as follows:

#incluir
#incluir
#incluir
usando namespace std;
int main ()
fStream STRM;
strm.aberto ("doc2.txt ", ios_base :: app);
se (!strm.está aberto())
cout << "File could not be opened!" << endl;
retornar 1;

char str [] = "D: Esta é a quarta linha.\ n ";
strm << str;
strm.fechar();
if (strm.está aberto())
cout << "Stream could not close!" << endl;
retornar 1;

cout << "Success, check file" << endl;
retornar 0;

O arquivo de saída agora deve ter quatro linhas.

Operação de fluxo de arquivos de entrada

Agora vamos demonstrar a leitura de um personagem de arquivo por personagem com fStream. Para ler um arquivo com fStream, use ios_base :: in como a bandeira na função de membro open (). O programa a seguir lê todo o conteúdo do arquivo e o exibe no console:

#incluir
#incluir
usando namespace std;
int main ()

fStream STRM;
strm.aberto ("doc1.txt ", ios_base :: in);
se (!strm.está aberto())
cout << "Open file failed" << endl;
retornar 1;

char c;
enquanto (!strm.eof ())
strm.obtenha (c);
cout << c;

strm.fechar();
retornar 0;

O EOF () é uma função de membro e retorna 1 quando o final do arquivo é atingido e zero caso contrário. O programa lê os caracteres do arquivo, um a um, até o final do arquivo ser alcançado. Ele usa a função get () membro, colocando o personagem de leitura na variável C, que já foi declarada. Cout envia cada personagem para o console. A saída deve ser:

A: Esta é a primeira linha.
B: Esta é a segunda linha.
C: Esta é a terceira linha.

Lendo o arquivo inteiro com uma função

O arquivo inteiro pode ser lido usando a função do membro:

Basic_istream & get (char_type* s, streamsize n, char_type delim);

Ele copia os caracteres do arquivo e os coloca em uma matriz de personagens. Faz isso até encontrar o delimitador, EOF, ou até que ele copie o N - 1 caractere. Ele se encaixará no caractere nulo ('\ 0') como o último personagem consecutivo na matriz. Isso significa que o número de caracteres escolhidos para a matriz deve ser estimado como pelo menos o número de caracteres de arquivo (incluindo qualquer \ n), mais um para o caractere nulo. Não copia o personagem delimitador. O código a seguir copia todo o arquivo de doc1.txt, usando esta função de membro:

#incluir
#incluir
usando namespace std;
int main ()

fStream STRM;
strm.aberto ("doc1.txt ", ios_base :: in);
se (!strm.está aberto())
cout << "Open file failed" << endl;
retornar 1;

Char arr [150];
strm.obtenha (arr, 150, EOF);
strm.fechar();
cout << arr << endl;
retornar 0;

Leitura de linha por linha

A função de membro a ser usada para ler em um arquivo com FStream Line by Line é:

Basic_istream& getLine (char_type* s, streamsize n, char_type delim);

Ele copia os caracteres do arquivo e os coloca em uma matriz de personagens. Faz isso até encontrar o delimitador (e.g. '\ n') ou até que ele copie o caractere n - 1. Ele se encaixará no personagem NUL ('\ 0') como o último personagem consecutivo na matriz. Isso significa que o número de caracteres escolhidos para a matriz deve ser estimado como pelo menos o número de caracteres visíveis, mais um para o caractere nulo. Não copia o personagem delimitador. O código a seguir copia todo o arquivo de doc1.txt linha por linha, usando esta função de membro:

#incluir
#incluir
usando namespace std;
int main ()

fStream STRM;
strm.aberto ("doc1.txt ", ios_base :: in);
se (!strm.está aberto())
cout << "Open file failed" << endl;
retornar 1;

Char arr [100];
enquanto (!strm.eof ())
strm.getLine (arr, 100, '\ n');
cout << arr << endl;

strm.fechar();
retornar 0;

Como '\ n' não é copiado ao copiar uma linha, o endl deve ser usado para a tela de saída. Observe que o número de caracteres na matriz e a variável de streamsize foi feito o mesmo. Se for conhecido com antecedência que o delimitador é '\ n', a seguinte função do membro pode ser usada:

Basic_istream& getLine (char_type* s, streamsize n);

Buscando no arquivo

Personagens incluindo '\ n' têm suas posições naturais no arquivo, começando de 0, depois 1, 2, 3 e assim por diante. A função de membro de Seekg (POS) apontaria o ponteiro para o caráter de uma posição no objeto de fluxo. Então, obtenha (c) pode ser usado para obter esse personagem. O personagem no 27^º Posição do Doc1 atual.O arquivo txt é 'b'. O código a seguir lê e exibe:

#incluir
#incluir
usando namespace std;
int main ()

fStream STRM;
strm.aberto ("doc1.txt ", ios_base :: in);
se (!strm.está aberto())
cout << "Open file failed" << endl;
retornar 1;

char c;
strm.Seekg (27);
strm.obtenha (c);
cout << c << endl;
strm.fechar();
retornar 0;

Se a posição dada for maior que a do último caractere no arquivo (menos 1), o nulo será retornado.

Função Tellg ()

Enquanto um arquivo está sendo lido, um ponteiro interno aponta para o próximo personagem a ser lido. A função do membro Tellg () pode obter o número de posição do personagem que o ponteiro está apontando para. Quando o arquivo é aberto, o Tellg () retornará 0 para o primeiro caractere. Depois de ler a primeira linha, Tellg () retornaria um número como 27 no exemplo abaixo:

#incluir
#incluir
usando namespace std;
int main ()

fStream STRM;
strm.aberto ("doc1.txt ", ios_base :: in);
se (!strm.está aberto())
cout << "Open file failed" << endl;
retornar 1;

Char arr [100];
int pos;
strm.getLine (arr, 100, '\ n');
POS = STRM.Tellg ();
strm.fechar();
cout << "Position in file is now: " << pos <retornar 0;

A saída é:

~ $ ./t9
A posição no arquivo é agora: 27

A função equivalente para a saída é o Tellp ().

Seekdir

Seekdir significa procurar orientação. Suas constantes definidas na biblioteca iOS_Base são: Breando para o início do arquivo, curs para a posição atual do arquivo e termine para o término do arquivo. A função acima seekg () está sobrecarregada para o fluxo de entrada como:

Basic_istream & Seekg (Off_type, iOS_Base :: Seekdir)

Então, se o ponteiro interno está apontando para o personagem na posição 27, contando o começo desde 0, então

strm.Seekg (0, ios_base :: cur);

Manterá o ponteiro na posição atual.

strm.Seekg (5, ios_base :: cur);

Vai levar o ponteiro 5 lugares à frente para apontar para "eu" no segundo "este" do doc1.arquivo txt.

strm.procureg (-5, ios_base :: cur);

Vai levar o ponteiro 5 lugares para trás para apontar para "eu" na primeira "linha" do doc1.arquivo txt. Observe que a posição do caractere nova '\ n', que não é exibida na saída, é contada.

Agora, não importa onde o ponteiro possa estar,

strm.Seekg (0, iOS_Base :: Beg);

Leva e mantém o ponteiro no início do arquivo; para apontar para o primeiro caractere do arquivo, com um deslocamento de 0. Nesse caso, ele apontará para "um".

strm.Seekg (5, iOS_Base :: BEG);

Levará o ponteiro para o início com um deslocamento de 5 lugares à frente; Ponto em "eu" no primeiro "este" do doc1.arquivo txt. Observe que o espaço único é contado como um personagem.

Um número inteiro negativo na posição de deslocamento para "ios_base :: beg" não é útil.

Bem, não importa onde o ponteiro possa estar,

strm.Seekg (0, iOS_base :: end);

Levará e manterá o ponteiro logo após o final do arquivo; para apontar para nada.

Um número inteiro positivo na posição de deslocamento para "ios_base :: end" não é útil.

strm.procureg (-5, ios_base :: end);

Levará o ponteiro até o fim com um deslocamento de 5 lugares atrás; Ponto para "eu" na última "linha" do doc1.arquivo txt. Observe que '\ n' e o ponto são contados como um personagem cada.

O código a seguir ilustra o uso da função, na posição atual, com um deslocamento negativo e positivo:

#incluir
#incluir
usando namespace std;
int main ()

fStream STRM;
strm.aberto ("doc1.txt ", ios_base :: in);
se (!strm.está aberto())
cout << "Open file failed" << endl;
retornar 1;

char c;
strm.Seekg (27);
strm.Seekg (0, ios_base :: cur);
strm.obtenha (c);
cout << c << endl;
strm.procureg (-5, ios_base :: cur);
strm.obtenha (c);
cout << c << endl;
strm.Seekg (+10, ios_base :: cur);
strm.obtenha (c);
strm.fechar();
retornar 0;

A saída é:

B
n

A função get () membro muda o ponteiro um lugar à frente após sua execução.

A função equivalente para a saída é:

BASIC_OSTREAM& Seekp (off_type, ios_base :: seekdir)

Observe o "P" em Seekp for put, em oposição a "G" em Seekg for Get.

Conclusão

A classe FStream lida com a entrada de um arquivo para um programa C ++ e saída do programa para o arquivo. Para usar o C ++ FStream, um objeto da classe deve ser instanciado. O objeto de fluxo então deve ser aberto para entrada ou saída ou ambos. Para anexar texto ao arquivo, o fluxo deve ser aberto para anexar. Faça o hábito de sempre fechar o fluxo depois de ser aberto e usado. Se o arquivo for um arquivo de imagem, então ios_base :: binário terá que ser orado usando | , com o segundo argumento da função de membro Open (). Esperamos que este artigo tenha ajudado você a usar o C ++ FStream.