E/S de arquivos C: criar, abrir, ler, gravar e fechar um arquivo

C Gerenciamento de arquivos

Um arquivo pode ser usado para armazenar um grande volume de dados persistentes. Como muitas outras linguagens, 'C' fornece as seguintes funções de gerenciamento de arquivos,

1. Criação de um arquivo
2. Abrindo um arquivo
3. Lendo um arquivo
4. Escrevendo em um arquivo
5. Fechando um arquivo

A seguir estão as funções de gerenciamento de arquivos mais importantes disponíveis em 'C,'

função	e propósito
fopen()	Criando um arquivo ou abrindo um arquivo existente
fechar()	Fechando um arquivo
fprintf()	Escrevendo um bloco de dados em um arquivo
fscanf()	Lendo dados de um bloco de um arquivo
getc()	Lê um único caractere de um arquivo
putc()	Grava um único caractere em um arquivo
pegar ()	Lê um número inteiro de um arquivo
putw()	Escrevendo um número inteiro em um arquivo
buscar ()	Define a posição de um ponteiro de arquivo para um local especificado
contar ()	Retorna a posição atual de um ponteiro de arquivo
retroceder ()	Define o ponteiro do arquivo no início de um arquivo

Como criar um arquivo

Sempre que você quiser trabalhar com um arquivo, o primeiro passo é criar um arquivo. Um arquivo nada mais é do que um espaço na memória onde os dados são armazenados.

Para criar um arquivo em um programa 'C', a seguinte sintaxe é usada,

FILE *fp;
fp = fopen ("file_name", "mode");

Na sintaxe acima, o arquivo é uma estrutura de dados definida na biblioteca padrão.

fopen é uma função padrão usada para abrir um arquivo.

• Se o arquivo não estiver presente no sistema, ele será criado e aberto.
• Se um arquivo já estiver presente no sistema, ele será aberto diretamente usando este função.

fp é um ponteiro de arquivo que aponta para o tipo de arquivo.

Sempre que você abre ou cria um arquivo, você deve especificar o que fará com o arquivo. Um arquivo em programação 'C' pode ser criado ou aberto para fins de leitura/escrita. Um modo é usado para especificar se você deseja abrir um arquivo para qualquer uma das finalidades fornecidas abaixo. A seguir estão os diferentes tipos de modos de programação 'C' que podem ser usados ​​ao trabalhar com um arquivo.

Modo de Arquivo	Descrição
r	Abra um arquivo para leitura. Se um arquivo estiver no modo de leitura, nenhum dado será excluído se um arquivo já estiver presente em um sistema.
w	Abra um arquivo para gravação. Se um arquivo estiver no modo de gravação, um novo arquivo será criado se o arquivo não existir. Se um arquivo já estiver presente em um sistema, todos os dados dentro do arquivo serão truncados e ele será aberto para fins de gravação.
a	Abra um arquivo em modo de acréscimo. Se um arquivo estiver no modo de acréscimo, o arquivo será aberto. O conteúdo do arquivo não muda.
r+	aberto para leitura e escrita desde o início
w+	aberto para leitura e escrita, substituindo um arquivo
a+	aberto para leitura e escrita, anexando ao arquivo

Na sintaxe fornecida, o nome do arquivo e o modo são especificados como strings, portanto, devem sempre ser colocados entre aspas duplas.

Exemplo:

#include <stdio.h>
int main() {
FILE *fp;
fp  = fopen ("data.txt", "w");
}

Saída:

O arquivo é criado na mesma pasta onde você salvou seu código.

Você pode especificar o caminho onde deseja criar seu arquivo

#include <stdio.h>
int main() {
FILE *fp;
fp  = fopen ("D://data.txt", "w");
}

Como fechar um arquivo

Deve-se sempre fechar um arquivo sempre que as operações no arquivo terminarem. Isso significa que o conteúdo e os links para o arquivo foram encerrados. Isso evita danos acidentais ao arquivo.

'C' fornece a função fclose para realizar a operação de fechamento de arquivo. A sintaxe de fclose é a seguinte,

fclose (file_pointer);

Exemplo:

FILE *fp;
fp  = fopen ("data.txt", "r");
fclose (fp);

A função fclose usa um ponteiro de arquivo como argumento. O arquivo associado ao ponteiro do arquivo é então fechado com a ajuda da função fclose. Ele retorna 0 se o fechamento foi bem-sucedido e EOF (fim do arquivo) se ocorreu um erro durante o fechamento do arquivo.

Após fechar o arquivo, o mesmo ponteiro de arquivo também pode ser usado com outros arquivos.

Na programação 'C', os arquivos são fechados automaticamente quando o programa é finalizado. Fechar um arquivo manualmente escrevendo a função fclose é uma boa prática de programação.

Gravando em um Arquivo

Em C, quando você grava em um arquivo, os caracteres de nova linha '\n' devem ser adicionados explicitamente.

A biblioteca stdio oferece as funções necessárias para escrever em um arquivo:

• fputc(char, ponteiro_arquivo): grava um caractere no arquivo apontado por file_pointer.
• fputs(str, ponteiro_arquivo): grava uma string no arquivo apontado por file_pointer.
• fprintf(ponteiro_de_arquivo, str, listas_variáveis): Imprime uma string no arquivo apontado por file_pointer. A string pode incluir opcionalmente especificadores de formato e uma lista de variáveis ​​listas_variáveis.

O programa abaixo mostra como realizar a gravação em um arquivo:

Função fputc():

#include <stdio.h>
int main() {
        int i;
        FILE * fptr;
        char fn[50];
        char str[] = "Guru99 Rocks\n";
        fptr = fopen("fputc_test.txt", "w"); // "w" defines "writing mode"
        for (i = 0; str[i] != '\n'; i++) {
            /* write to file using fputc() function */
            fputc(str[i], fptr);
        }
        fclose(fptr);
        return 0;
    }

Saída:

O programa acima escreve um único caractere no fputc_test.txt arquivo até chegar ao próximo símbolo de linha “\n” que indica que a frase foi escrita com sucesso. O processo consiste em pegar cada caractere do array e gravá-lo no arquivo.

1. No programa acima, criamos e abrimos um arquivo chamado fputc_test.txt em modo de gravação e declaramos nossa string que será escrita no arquivo.
2. Fazemos uma operação de gravação caractere por caractere usando o loop for e colocamos cada caractere em nosso arquivo até que o caractere “\n” seja encontrado, então o arquivo é fechado usando a função fclose.

fputs() Função:

#include <stdio.h>
int main() {
        FILE * fp;
        fp = fopen("fputs_test.txt", "w+");
        fputs("This is Guru99 Tutorial on fputs,", fp);
        fputs("We don't need to use for loop\n", fp);
        fputs("Easier than fputc function\n", fp);
        fclose(fp);
        return (0);
    }

Saída:

1. No programa acima, criamos e abrimos um arquivo chamado fputs_test.txt em modo de gravação.
2. Depois de fazermos uma operação de gravação usando a função fputs() escrevendo três diferentes cordas
3. Em seguida, o arquivo é fechado usando a função fclose.

fprintf()Função:

#include <stdio.h>
    int main() {
        FILE *fptr;
        fptr = fopen("fprintf_test.txt", "w"); // "w" defines "writing mode"
        /* write to file */
        fprintf(fptr, "Learning C with Guru99\n");
        fclose(fptr);
        return 0;
    }

Saída:

1. No programa acima, criamos e abrimos um arquivo chamado fprintf_test.txt em modo de gravação.
2. Depois que uma operação de gravação é executada usando a função fprintf() escrevendo uma string, o arquivo é fechado usando a função fclose.

Lendo dados de um arquivo

Existem três funções diferentes dedicadas à leitura de dados de um arquivo

• fgetc(ponteiro_arquivo): Ele retorna o próximo caractere do arquivo apontado pelo ponteiro do arquivo. Quando o final do arquivo for atingido, o EOF será enviado de volta.
• fgets(buffer, n, ponteiro_arquivo): Ele lê n-1 caracteres do arquivo e armazena a string em um buffer no qual o caractere NULL '\0' é anexado como o último caractere.
• fscanf(ponteiro_de_arquivo, especificadores de conversão, endereços_variáveis): é usado para analisar e analisar dados. Ele lê caracteres do arquivo e atribui a entrada a uma lista de ponteiros variáveis endereços_variáveis ​​usando especificadores de conversão. Tenha em mente que, assim como acontece com o scanf, o fscanf para de ler uma string quando um espaço ou uma nova linha é encontrado.

O programa a seguir demonstra a leitura do arquivo fputs_test.txt usando as funções fgets(),fscanf() e fgetc() respectivamente:

#include <stdio.h>
int main() {
        FILE * file_pointer;
        char buffer[30], c;

        file_pointer = fopen("fprintf_test.txt", "r");
        printf("----read a line----\n");
        fgets(buffer, 50, file_pointer);
        printf("%s\n", buffer);

        printf("----read and parse data----\n");
        file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer
        char str1[10], str2[2], str3[20], str4[2];
        fscanf(file_pointer, "%s %s %s %s", str1, str2, str3, str4);
        printf("Read String1 |%s|\n", str1);
        printf("Read String2 |%s|\n", str2);
        printf("Read String3 |%s|\n", str3);
        printf("Read String4 |%s|\n", str4);

        printf("----read the entire file----\n");

        file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer
        while ((c = getc(file_pointer)) != EOF) printf("%c", c);

        fclose(file_pointer);
        return 0;
    }

Resultado:

----read a line----
Learning C with Guru99

----read and parse data----
Read String1 |Learning|
Read String2 |C|
Read String3 |with|
Read String4 |Guru99|
----read the entire file----
Learning C with Guru99

1. No programa acima, abrimos o arquivo chamado “fprintf_test.txt” que foi escrito anteriormente usando a função fprintf() e contém a string “Aprendendo C com Guru99”. Lemos usando a função fgets() que lê linha por linha onde o tamanho do buffer deve ser suficiente para lidar com a linha inteira.
2. Reabrimos o arquivo para redefinir o arquivo ponteiro para apontar para o início do arquivo. Crie várias variáveis ​​de string para lidar com cada palavra separadamente. Imprima as variáveis ​​para ver seu conteúdo. O fscanf() é usado principalmente para extrair e analisar dados de um arquivo.
3. Abra novamente o arquivo para redefinir o arquivo de ponteiro para apontar para o início do arquivo. Leia os dados e imprima-os do arquivo caractere por caractere usando a função getc() até que a instrução EOF seja encontrada
4. Após realizar uma operação de leitura do arquivo utilizando diferentes variantes, fechamos novamente o arquivo utilizando a função fclose.

Leitura e gravação interativa de arquivos com getc e putc

Estas são as operações de arquivo mais simples. Getc significa obter caractere e putc significa colocar caractere. Essas duas funções são usadas para lidar com apenas um caractere por vez.

O programa a seguir demonstra as funções de manipulação de arquivos na programação 'C':

#include <stdio.h>
int main() {
        FILE * fp;
        char c;
        printf("File Handling\n");
        //open a file
        fp = fopen("demo.txt", "w");
        //writing operation
        while ((c = getchar()) != EOF) {
            putc(c, fp);
        }
        //close file
        fclose(fp);
        printf("Data Entered:\n");
        //reading
        fp = fopen("demo.txt", "r");
        while ((c = getc(fp)) != EOF) {
            printf("%c", c);
        }
        fclose(fp);
        return 0;
    }

Saída:

1. No programa acima, criamos e abrimos um arquivo chamado demo em modo de gravação.
2. Após a execução de uma operação de gravação, o arquivo é fechado usando a função fclose.
3. Abrimos novamente um arquivo que agora contém dados em modo de leitura. Um loop while será executado até que o eof seja encontrado. Assim que o final do arquivo for encontrado, a operação será encerrada e os dados serão exibidos usando a função printf.
4. Após realizar uma operação de leitura, o arquivo é fechado novamente usando a função fclose.

Resumo

• Um arquivo é um espaço na memória onde os dados são armazenados.
• A programação 'C' fornece várias funções para lidar com um arquivo.
• Um mecanismo de manipulação dos arquivos é denominado gerenciamento de arquivos.
• Um arquivo deve ser aberto antes de realizar operações nele.
• Um arquivo pode ser aberto em modo de leitura, gravação ou acréscimo.
• As funções Getc e putc são usadas para ler e escrever um único caractere.
• A função fscanf() permite ler e analisar dados de um arquivo
• Podemos ler (usando o getc função) um arquivo inteiro fazendo um loop para cobrir todo o arquivo até que o EOF seja encontrado
• Podemos escrever em um arquivo após criar seu nome, usando a função fprintf () e deve ter o caractere de nova linha no final da string de texto.