Utils for files manipulation in C

files_42.c

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   files.c                                            :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: mathferr <[email protected]>          +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2020/03/03 02:12:09 by mathferr          #+#    #+#             */
/*   Updated: 2020/03/03 02:12:10 by mathferr         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BUF_SIZE 4096

static void ft_putchar_fd(int fd, char *str)
{
	/*	Escreve caracteres num determinado fd	*/
	write(fd, str, strlen(str));
}

static void	ft_putstr(char *str)
{
	while (*str != '\0')
	{
		write(1, str, 1);
		str++;
	}	
}

int main(void)
{
	/*	File descriptor -> representa um arquivo aberto ou criado	*/
	int fd;
	/*	Representa o retorno de um arquivo lido por read()	*/
	int ret;
	/*	Char para armazenar o que foi lido do arquivo, pode ser static, sera inicializado com malloc	*/
	char buf[BUF_SIZE + 1];

	/*  Abrindo um arquivo/criando chamado 42 e com permissão de escrita		*/
	/*	fd = open("42", O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR); 	*/
	/*	Abrindo um arquivo chamdo 42 com permissão apenas de leitura -> para usar read()	*/
	fd = open("42", O_RDONLY);

	if(fd == -1)
	{
		printf("open() ERROR\n");
		return (1);
	}
	printf("%d\n", fd);

	/*	Read() -> Lendo conteudo de um arquivo	*/
	/*	Lendo 4096 bytes do arquivo chamado 42	e salvando em buf	*/
	ret = read(fd, buf, BUF_SIZE);
	/*	Finalizando a string buf com \0		*/
	buf[ret] = '\0';
	/*	Imprimindo o numero de caracteres lido do arquivo	*/
	printf("%d\n", ret);
	/*	Imprimindo conteudo lido do arquivo		*/
	ft_putstr(buf);	

	/*	Escrevendo conteudo dentro do arquivo	*/
	ft_putchar_fd(fd, "Hello World !");

	/*	Fechando (encerrando um arquivo)	*/
	int cls = close(fd);

	if(cls == -1)
	{
		printf("close() ERROR\n");
		return (1);
	}
	printf("\n%d\n", cls);

	return (0);
}

read_all_file.c

/*
**
** Usando as funções fgets e getline
** para ler um arquivo em linguagem C
**
*/ 
/*
** compilar com: 
** gcc -Wall -Wextra -Werror -pedantic -std=c17 all_file.c
*/ 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    // Abrindo um arquivo como um ponteiro do tipo FILE
    FILE    *fp = fopen("lorem.txt", "r");
    // Variavel que ira guardar as partes de texto lidas de um arqiuvo
    char chunk[128];
    
    // Testando se a abertura do arquivo funcionou
    if (fp == NULL)
    {
        perror("Impossível abrir o arquivo!");
        exit(-1);
    }
    // Lendo todo o arquivo e imprimindo na saida padrao
    while(fgets(chunk, sizeof(chunk), fp) != NULL)
    {
        fputs(chunk, stdout);
        fputs("|*\n", stdout);
    }
    // Fechando o arquivo
    fclose(fp);
    return 0;
}

read_line_by_line.c

/*
**
** Usando a função fgets
** para ler um arquivo linha a linha
** em linguagem C
**
*/ 
/*
** compilar com: 
** gcc -Wall -Wextra -Werror -pedantic -std=c17 line_by_line.c
*/ 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char chunk[128];
    FILE    *fp = fopen("lorem.txt", "r");

    if (fp == NULL)
    {
        perror("Impossível abrir o arquivo!");
        exit(-1);
    }
    // Salvando os pedaços de texto em um chunk na variavel linhas
    size_t len = sizeof(chunk);
    char *line = malloc(len);
    if(line == NULL)
    {
        perror("Impossível alocar espaço para o chunk de linha!");
        exit(-1);
    }
    line[0] = '\0'; 
    while(fgets(chunk, sizeof(chunk), fp) != NULL)
    {
        // Recalculando o tamanho do chunk de uma linha se necessário
        if(len - strlen(line) < sizeof(chunk))
        {
            len *= 2;
            if((line = realloc(line, len)) == NULL)
            {
                perror("Impossível realocar memória para uma nova linha!");
                free(line);
                exit(-1);
            }
        }
        // Concatenando o pedaço de texto com o fim do chunk de uma linha
        strcat(line, chunk);
        // Testando se uma linha tem um '\n', se sim processar a linha de texto
        if(line[strlen(line) - 1] == '\n')
        {
            // Imprimindo as linhas do arquivo
            //fputs(line, stdout);
            //fputs("|*\n", stdout);
            // imprimindo o tamanho de uma linha
            printf("Tamanho da linha: %zd\n", strlen(line));
            line[0] = '\0';
        }
    }
    fclose(fp);
    free(line);
    // imprimindo o tamanho máximo de linhas
    printf("\n\nTamanho máximo de linhas: %zd\n", len);
    return 0;
}

read_line_by_line_getline.c

/*
**
** Usando a função getline
** para ler um arquivo linha a linha
** em linguagem C
**
*/ 
/*
** compilar com:
** gcc -Wall -Wextra -Werror -pedantic -std=gnu17 line_by_line_getline.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    FILE    *fp = fopen("lorem.txt", "r");

    if (fp == NULL)
    {
        perror("Impossível abrir o arquivo!");
        exit(-1);
    }
    // Lendo linhas usando a função POSIX getline
    char *line = NULL;
    size_t len = 0;
    while(getline(&line, &len, fp) != -1)
    {
        //fputs(line, stdout);
        //fputs("|*\n", stdout);
        printf("Tamanho da linha: %zd\n", strlen(line));
    }
    fclose(fp);
    // A função getline() aloca memória para uma linha, então é preciso liberar a memória
    free(line);     // getline() ira usar realloc para recalcular o tamanho do input buf se necessário
                    // isso torna necessário usar o free para liberar a memória utilizada
    printf("\n\nTamanho máximo de linhas: %zd\n", len);
    return 0;
}