Cara, mostra a parte do seu código responsável pela leitura da entrada padrão. Dependendo de como você está lendo, pode ser que essa alocação de memória esteja sendo superdimensionada por vários motivos.
1
1
Opa, Andre (ou André, não sei)!
Segue abaixo a função:
char * read_line(FILE * stream) {
char * buffer = (char *) malloc(sizeof(char) * MAX_BUFFER_SIZE);
int read = strlen(fgets(buffer, MAX_BUFFER_SIZE, stream));
if(read < MAX_BUFFER_SIZE && buffer[read - 1] == '\n') {
buffer[--read] = '\0';
}
printf("characters read: %d\n", read);
return buffer;
}
1
E como vc usa a função read_line? É em um loop?
Em qual momento você libera a memória alocada para o buffer?
1
Se der ruim no codigo voce nao tem como saber, fica top se implementar algo para verificar erros, Cuidado com esses MAX_BUFFER_SIZE, deixa ele definido no comeco do codigo e bem visivel e colocando uma cerejinha no topo desse bolo, usa typedef
algo assim oh (nao ta dos melhores codigos) testa e faca suas melhorias:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define MAX_BUFFER_SIZE 1024
typedef char* LinePtr;
typedef FILE* FilePtr;
LinePtr read_line(FilePtr stream) {
if (!stream) {
perror("Error: Stream pointer is NULL.");
return NULL;
}
LinePtr buffer = (LinePtr) malloc(sizeof(char) * MAX_BUFFER_SIZE);
if (!buffer) {
perror("Error: Memory allocation failed.");
return NULL;
}
LinePtr line = fgets(buffer, MAX_BUFFER_SIZE, stream);
if (!line) {
free(buffer);
return NULL;
}
int read = strlen(line);
if (read > 0 && line[read - 1] == '\n') {
line[--read] = '\0';
}
printf("Characters read: %d\n", read);
return line;
}
1
Complementando:
- em C, você não precisa fazer cast do
malloc - o
sizeofde umcharsempre é 1. Claro que pode até mantê-lo para deixar o código mais claro, mas eu diria que isso é discutível (pra mim, é redundante)
Ou seja, a parte que aloca memória poderia ser apenas:
char *buffer = malloc(MAX_BUFFER_SIZE);
1
Absolutamente correto, eu meio que copie o codigo dele e fiz umas alteracoes.
Casteando malloc voce assume que LinePtr seja definido como um ponteiro para uma estrutura que contém uma matriz char e que o tamanho da estrutura seja igual a sizeof(char) * MAX_BUFFER_SIZE. Se o tamanho da estrutura não for igual a sizeof(char) * MAX_BUFFER_SIZE, isso pode resultar em erros de alocação de memória ou comportamento indefinido.
O que o @kht propoz simplesmente aloca um bloco de memória de tamanho MAX_BUFFER_SIZE e retorna um ponteiro para o início do bloco.
muito mais simples.
Nao esquece que não é necessário converter o valor de retorno de malloc em C, pois o ponteiro void retornado por malloc pode ser convertido implicitamente em qualquer outro tipo de ponteiro.