Dominando File I/O em C: Criar, Abrir, Ler, Escrever e Fechar Arquivos com Confiança

Visão Geral de Gerenciamento de Arquivos em C

Em C, a biblioteca padrão stdio.h oferece um conjunto abrangente de funções para trabalhar com dados persistentes em disco. Dominando essas ferramentas, você pode criar, ler, escrever e fechar arquivos de forma confiável, garantindo integridade de dados e estabilidade do programa.

Principais Funções de Manipulação de Arquivos

Função	Propósito
fopen()	Abrir arquivo existente ou criar novo.
fclose()	Fechar arquivo aberto e liberar recursos.
fprintf()	Escrever texto formatado em arquivo.
fscanf()	Ler dados formatados de arquivo.
getc()	Obter um único caractere de arquivo.
putc()	Escrever um único caractere em arquivo.
fgets()	Ler linha inteira em buffer.
fputs()	Escrever string em arquivo sem formatação.
fseek()	Mover ponteiro de arquivo para posição específica.
ftell()	Obter posição atual do ponteiro de arquivo.
rewind()	Resetar ponteiro de arquivo para o início.

Modos de Arquivo Explicados

Modo	Descrição
"r"	Abrir para leitura; falha se arquivo não existe.
"w"	Abrir para escrita; trunca arquivo existente ou cria novo.
"a"	Abrir para anexar; escritas são adicionadas ao final do arquivo.
"r+"	Abrir para leitura e escrita do início.
"w+"	Abrir para leitura e escrita; trunca arquivo existente.
"a+"	Abrir para leitura e escrita; anexa novos dados.

Criando um Arquivo

Para criar ou abrir um arquivo, primeiro declare um ponteiro de arquivo, então chame fopen() com o nome de arquivo e modo desejados:

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

Se o arquivo não existe, fopen() o cria. Se já existe, o modo determina se o conteúdo é preservado ou sobrescrito.

Você também pode especificar um caminho absoluto:

fp = fopen("D:/data.txt", "w");

Imagens ilustrando a etapa de criação de arquivo:

Fechando um Arquivo

Após terminar todas as operações de arquivo, sempre chame fclose() para liberar o descritor de arquivo e dar flush nos buffers:

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

A função retorna 0 em sucesso e EOF em erro. Embora o sistema operacional feche arquivos automaticamente quando o programa sai, fechamento explícito é considerado melhor prática.

Escrevendo em um Arquivo

Ao escrever, lembre-se de adicionar caracteres de nova linha (\n) explicitamente onde necessário. Abaixo estão as funções de escrita mais comuns:

• fputc(char, FILE*) – Escreve um único caractere.
• fputs(const char*, FILE*) – Escreve string terminada em null.
• fprintf(FILE*, const char*, …) – Escreve saída formatada.

Exemplo: fputc()

#include <stdio.h>
int main() {
    int i;
    FILE *fptr;
    const char *str = "Guru99 Rocks\n";
    fptr = fopen("fputc_test.txt", "w");
    for (i = 0; str[i] != '\n'; i++) {
        fputc(str[i], fptr);
    }
    fclose(fptr);
    return 0;
}

Arquivo de saída fputc_test.txt contém o texto:

Exemplo: fputs()

#include <stdio.h>
int main() {
    FILE *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;
}

Arquivo resultante fputs_test.txt:

Exemplo: fprintf()

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

Arquivo resultante fprintf_test.txt:

Lendo de um Arquivo

Três funções primárias leem dados:

• fgetc(FILE*) – Retorna o próximo caractere.
• fgets(char*, int, FILE*) – Lê até n-1 caracteres em buffer.
• fscanf(FILE*, const char*, …) – Parseia entrada formatada.

Abaixo está uma demonstração completa que lê fprintf_test.txt usando os três métodos:

#include <stdio.h>
int main() {
    FILE *fp;
    char buffer[50], c;
    fp = fopen("fprintf_test.txt", "r");
    printf("----read a line----\n");
    fgets(buffer, 50, fp);
    printf("%s\n", buffer);
    fclose(fp);
    fp = fopen("fprintf_test.txt", "r");
    printf("----read and parse data----\n");
    char str1[10], str2[2], str3[20], str4[2];
    fscanf(fp, "%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);
    fclose(fp);
    fp = fopen("fprintf_test.txt", "r");
    printf("----read the entire file----\n");
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }
    fclose(fp);
    return 0;
}

Saída do programa:

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

I/O Caracter-por-Caracter Interativo com getc e putc

Este exemplo mínimo demonstra leitura de entrada do usuário, escrita em arquivo e leitura de volta:

#include <stdio.h>
int main() {
    FILE *fp;
    int c;
    printf("File Handling\n");
    fp = fopen("demo.txt", "w");
    while ((c = getchar()) != EOF) {
        putc(c, fp);
    }
    fclose(fp);
    printf("Data Entered:\n");
    fp = fopen("demo.txt", "r");
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }
    fclose(fp);
    return 0;
}

Execução de exemplo:

Conclusão

• Um arquivo é um espaço de armazenamento persistente em disco.
• A biblioteca padrão C fornece fopen, fclose, fprintf, fscanf e funções relacionadas para manipulação confiável de arquivos.
• Abra sempre um arquivo no modo correto para controlar comportamento de leitura, escrita ou anexação.
• Feche arquivos explicitamente para dar flush nos buffers e liberar recursos do sistema.
• Use fgetc e putc para streams simples de caracteres, e fgets / fscanf para entrada baseada em linhas ou formatada.
• Ao escrever, lembre-se de terminar strings com \n se pretender quebras de linha.
• Tratamento adequado de erros (verificando ponteiros NULL e valores de retorno) é essencial para aplicações robustas.