C Files I/O: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. Ler 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 propósito fopen() Criando um arquivo ou abrindo um arquivo existentefclose() Fechando um arquivofprintf() Gravando um bloco de dados em um arquivofscanf() Lendo os dados de um bloco de um arquivogetc() Lê um único caractere de um arquivoputc() Grava um único caractere em um arquivogetw() Lê um inteiro de um arquivoputw() Escrevendo um inteiro em um arquivofseek() Define a posição de um ponteiro de arquivo para um local especificadoftell () Retorna a posição atual de um ponteiro de arquivoretroceder () Define o ponteiro do arquivo no início de um arquivo

Neste tutorial, você aprenderá-

• Como criar um arquivo
• Como fechar um arquivo:
• Escrevendo em um arquivo
• fputc() Função:
• fputs() Função:
• fprintf() Função:
• Ler dados de um arquivo
• Leitura e gravação interativa de arquivos com getc e putc

Como criar um arquivo

Sempre que você quiser trabalhar com um arquivo, o primeiro passo é criar um arquivo. Um arquivo nada mais é do que o espaço em uma 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 que é 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 esta função.

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

Sempre que você abre ou cria um arquivo, 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 um dos propósitos abaixo. A seguir estão os diferentes tipos de modos na programação 'C' que podem ser usados ​​ao trabalhar com um arquivo.
Modo de arquivo Descrição rAbra 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.wAbra um arquivo para gravação. Se um arquivo estiver no modo de gravação, um novo arquivo será criado se um arquivo não existir. Se um arquivo já estiver presente em um sistema, todos os dados dentro do arquivo serão truncados e abertos para fins de gravação.a Abra um arquivo
no modo anexo. 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íciow+open para leitura e escrita, sobrescrevendo um arquivoa+open 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 estar entre aspas duplas.

Exemplo:

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

Resultado:

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 do fclose é a seguinte,

fclose (file_pointer);

Exemplo:

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

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

Depois de 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 é encerrado. Fechar um arquivo manualmente escrevendo a função fclose é uma boa prática de programação.

Escrevendo em um arquivo

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

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

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

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

Resultado:

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

1. No programa acima, criamos e abrimos um arquivo chamado fputc_test.txt no modo de gravação e declaramos nossa string que será gravada no arquivo.
2. Fazemos uma operação de escrita 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.

função fputs():

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

RESULTADO:

1. No programa acima, criamos e abrimos um arquivo chamado fputs_test.txt no modo de gravação.
2. Depois de fazermos uma operação de escrita usando a função fputs() escrevendo três strings diferentes
3. Então 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;
    }

RESULTADO:

1. No programa acima, criamos e abrimos um arquivo chamado fprintf_test.txt no 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.

Ler dados de um arquivo

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

• fgetc(file_pointer): Ele retorna o próximo caractere do arquivo apontado pelo ponteiro de arquivo. Quando o final do arquivo for atingido, o EOF é enviado de volta.
• fgets(buffer, n, file_pointer): 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(file_pointer, conversion_specifiers, variable_adresses) :é usado para analisar e analisar dados. Ele lê os caracteres do arquivo e atribui a entrada a uma lista de ponteiros de variáveis ​​variable_adresses usando especificadores de conversão. Lembre-se de que, como no 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 “Learning C with Guru99”. Nós o 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 strings 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. Reabra 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. Depois de realizar uma operação de leitura de arquivo usando diferentes variantes, fechamos novamente o arquivo usando 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 manipular apenas um único 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;
    }

Resultado:

1. No programa acima, criamos e abrimos um arquivo chamado demo no modo de gravação.
2. Depois que uma operação de gravação é executada, 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 é novamente fechado 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 com os arquivos é chamado de gerenciamento de arquivos.
• Um arquivo deve ser aberto antes de realizar operações nele.
• Um arquivo pode ser aberto no 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 function) um arquivo inteiro fazendo um loop para cobrir todo o arquivo até que o EOF seja encontrado
• Podemos escrever em um arquivo depois de criar seu nome, usando a função fprintf() e deve ter o caractere de nova linha no final do texto da string.