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. Assim como muitas outras linguagens, 'C' oferece os seguintes recursos de gerenciamento de arquivos. funções,

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,'

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 esta função.

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

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.

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

Por 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);

Por exemplo:

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

A função `fclose` recebe um ponteiro para um arquivo como argumento. O arquivo associado a esse ponteiro é então fechado com a ajuda da função `fclose`. Ela retorna 0 se o fechamento for bem-sucedido e EOF (fim do arquivo) se ocorrer 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, file_pointer): Escreve um caractere no arquivo apontado por file_pointer.
• fputs(str, file_pointer): Escreve uma string no arquivo apontado por file_pointer.
• fprintf(file_pointer, str, variable_lists): Imprime uma string no 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;
    }

Saída:

O programa acima escreve um único caractere no arquivo fputc_test.txt até encontrar o símbolo de próxima linha “\n”, que indica que a frase foi escrita com sucesso. O processo consiste em pegar cada caractere do array e escrevê-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. Após realizarmos uma operação de escrita usando a função fputs(), escrevendo três strings diferentes
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(file_pointer): Retorna o próximo caractere do arquivo apontado pelo ponteiro de arquivo. Quando o final do arquivo é atingido, o EOF (fim de arquivo) é retornado.
• fgets(buffer, n, file_pointer): 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_de_variáveis): É usado para analisar e interpretar dados. Ele lê caracteres do arquivo e atribui a entrada a uma lista de ponteiros para variáveis, `endereços_de_variáveis`, usando especificadores de conversão. Lembre-se de que, assim como com `scanf`, `fscanf` para de ler uma string quando encontra um espaço ou uma nova linha.

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 que contém o texto “Aprendendo C com GuruA string "99". Nós a 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 ponteiro para apontar para o início do arquivo. Criamos várias variáveis ​​de string para lidar com cada palavra separadamente. Imprimimos as variáveis ​​para ver seus conteúdos. A função `fscanf()` é usada principalmente para extrair informações do arquivo.trace 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.

Perguntas Frequentes