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.
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;
}
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:
```c++
#include
#include
#include
#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;
}
```
Complementando:
- em C, você [não precisa fazer *cast* do `malloc`](https://stackoverflow.com/q/605845)
- o `sizeof` de um `char` [sempre é 1](https://stackoverflow.com/a/2215454). 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:
```c
char *buffer = malloc(MAX_BUFFER_SIZE);
```
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.