Início / coding / Perguntas / 79427535
Accepted
tr41z
Asked: 2025-02-10 23:19:01 +0800 CST

Manipulação adequada de memória para entrada do usuário em C

  • 772

Estou tentando manipular corretamente a entrada do usuário em C, principalmente ao ler um caminho de arquivo do usuário.

No entanto, tenho algumas preocupações:

  1. Como refatorar esse código para lidar com alocação dinâmica de memória?
  2. Como devo lidar corretamente com a alocação de memória dinâmica para entrada do usuário quando o comprimento é desconhecido?
  3. Qual é a maneira mais segura de aceitar entradas do usuário para caminhos de arquivo?

Meu código atual:

#include <stdio.h>

int main() {
    char filePath[1024];

    printf("Please provide file to encrypt (File Path): ");
    scanf("%1024s", filePath); // Is this safe?

    printf("You entered: %s\n", filePath);
    return 0;
}

Encontrei uma fonte no site da Microsoft sugerindo que eu especifique uma largura para o %sespecificador de formato em scanf(por exemplo, %1024sem vez de %s), mas ainda é um tamanho fixo e quero que ele seja alocado dinamicamente.

c

2 respostas

  1. Best Answer

    Conforme observado nos comentários, seria melhor utilizar a fgetsfunção de biblioteca padrão que permite especificar o tamanho do buffer para evitar problemas de estouro de buffer.

    #include <stdio.h>

int main() {
    char filePath[1024];

    printf("Please provide file to encrypt (File Path): ");
    fgets(filePath, sizeof(filePath), stdin);

    printf("You entered: %s\n", filePath);
    return 0;
}

    Usar scanfwith %scom ou sem um especificador de largura também restringirá você a ler uma string delimitada por espaços em branco. Isso proíbe espaços na sua entrada.

    Se você quiser ler uma linha inteira de tamanho desconhecido, precisará sair da biblioteca padrão ou reinventar a roda você mesmo. Não deve ser difícil. Eu preparei o seguinte em alguns minutos, e talvez haja espaço para melhorias, mas isso também não levaria muito tempo.

    O processo chave é alocar um buffer inicial, então ler nele caractere por caractere até atingir EOFou uma nova linha. Se o comprimento atingir os limites do seu buffer, realoque.

    Duas armadilhas comuns de gerenciamento de memória com isso:

    • Aumentar seu buffer por um fator de 1 (adicionado). Se fizer isso, você estará fazendo um número linear de chamadas para realloc, o que pode precisar copiar seu buffer a cada vez . Isso é caro. Aumente por um fator de 2 1 (multiplicado) e suas chamadas para reallocserão logarítmicas. Começar com um tamanho de orçamento inicial maior também é uma opção.
    • Ao chamar realloc o teste que ele obteve sucesso antes de atribuir ao buffer original. Se você não fizer isso e reallocfalhar, você não conseguirá acessar a memória alocada originalmente, levando a um vazamento de memória.
    #include <stdlib.h>
#include <stdio.h>

char *read_line(FILE *fp) {
    size_t sz = 8;
    size_t len = 0;
    char *buf = malloc(sz);
    int ch;

    while ((ch = fgetc(fp)) != EOF) {
        // Grow the buffer if necessary by a factor of 2
        // to avoid extraneous calls to realloc
        if (len >= sz) {
            // Don't immediately overwrite the buf pointer 
            // in case realloc fails
            char *temp = realloc(buf, sz * 2);
            if (!temp) {
                free(buf);
                return NULL;
            }

            buf = temp;
            sz *= 2;
        }

        // Terminate on a newline
        if (ch == '\n') {
            buf[len] = '\0';
            return buf;
        }

        buf[len++] = ch;
    }

    buf[len] = '\0';

    return buf;
}

    Um refinamento adicional disso pode ser usar um size_tponteiro como argumento e permitir que a função grave o comprimento da string lida em uma variável, de modo que o tamanho da string de entrada não precise ser calculado posteriormente com strlen.

    1 A taxa de crescimento de memória ideal é uma questão de algum debate. Veja: Qual é a taxa de crescimento ideal para um array alocado dinamicamente?

    • 4

  2. Tente usar, getline(&buffer,&size,stdin);pois ele aloca memória dinamicamente para a entrada.

    Você pode simplesmente ter um código funcional com algo assim:

    #include <stdio.h>
#include <stdlib.h>

int main() {
    char *buffer = NULL;
    size_t len = 0;

    if (getline(&buffer, &len, stdin) != -1) { 
        printf("Entered Line: %s\nLenght: %zu", buffer, len); 
    } else { 
        perror("getline failed"); 
    } 
 
    // Remember to free the memory after the string is used
    free(buffer);
    return 0; 
}
    • 1

relate perguntas