Colo allocate a memory based on the size the user typed

Question

How can I get it right after the user enters a string the program counts the number x of characters of this and allocate X bytes to it?

I am not able to do it, I tried for example to make after the user type the string, this:

ponteiro = (char *) malloc (strlen(string));

In the above code, the user giving an input, for example, of the type: ABCDEF, would cause strlen to count 6 characters, thus allocating to the string 6 bytes.

But it goes wrong, since the memory allocation would be happening later, so before the string was 'picked up' there would be no bytes allocated to store it.
Does anyone know how to fix it?

Answer 1

There are not many options. Basically you either allocate a sufficient amount for what you need or ask how much you want to allocate.

The second option really is terrible. From the usability point of view it doesn’t make any sense.

The first option has the disadvantage of possibly allocating more memory than actually needed. But who cares. This is no longer a problem on any kind of device unless you want to input really long text, but you wouldn’t do it simply anyway, in a long text you would have a data structure to manage it.

One might think that there is also the disadvantage of imposing a ceiling. But this is an advantage. Letting a user what is the maximum limit of text to type is the last thing the program should do. Again, if you need something more complex, you’ll need a more complex program.

So the solution is to do this:

#include <stdio.h>
#include <stdlib.h>
int main(){
    char *ponteiro = malloc(100); //um caractere será ocupado pelo terminador \0
    printf("String: ");
    scanf("%99s", ponteiro); //permite digitar um caractere a menos que o alocado 
    free(ponteiro);
    return 0;
}

Behold working in the ideone. And in the repl it.. Also put on the Github for future reference.

Now responses have appeared that show creative algorithms but that probably will be Overkill. My solution wastes memory, the others presented waste allocation time and in the commentary appeared one that wastes or two but in moderate quantities.

Have you noticed that there is no free lunch? You have to decide what you want to waste. In a simple example any can be wasted smoothly. I would use the occam’s razor and would keep the simplest. If I preferred the most complicated I would have posted it.

I could use an optimized version and better handled in more complex problems where I really was having memory problems and didn’t know the size of what I need in data input. I don’t have any of these problems ever so I never worried about it. I guess you shouldn’t either.

Answer 2

There is a way to do what you want, but the performance of the code is questionable depending on the situation.

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

#define ALLOCATION_STEP 5

int main(void)
{
    int mem_left = ALLOCATION_STEP;
    int mem_size = mem_left + 1;
    int length = 0;
    int realloc_cnt = 0;
    char *buff = (char *)malloc(mem_left);
    char c = 0;
    while((c = getchar()) != '\n') {
        if(mem_left == 0) { // precisamos de mais memoria
            char *tmp = (char *)realloc(buff,mem_size + ALLOCATION_STEP);
            if(tmp == NULL) {
                printf("Falha na aquisicao de memoria!\n");
                free(buff);
                return -1;
            }
            buff = tmp;
            mem_left = ALLOCATION_STEP;
            mem_size += mem_left;
            ++realloc_cnt;
        }
        buff[length++] = c;
        --mem_left;
    }

    buff[length] = '\0'; // fecha a string

    printf("Tamanho: %d\n",length);
    printf("Memoria: %d\n",mem_size);
    printf("Padding: %d\n",mem_size - (length+1));
    printf("Realocacoes: %d\n",realloc_cnt);
    printf("String: %s\n",buff);

    free(buff);
    buff = NULL;

    return 0;
}

The above code allocates an initial amount of memory given by the value of ALLOCATION_STEP, then it starts reading the input stream until it finds a line break \n, throughout the process it copies the characters from the stream to the variable buff, if the remaining amount of memory indicated by mem_left come to 0 he realoca more ALLOCATION_STEP bytes of memory to continue the process until the end or until an allocation error occurs.

The problem is: A ALLOCATION_STEP too low can cause many relocations to occur making the performance of code questionable, there is also misuse of function realloc that can cause problems.

Answer 3

Simple: the same way C++ does with std::string. Leaves input buffer, reads from Chunk in Chunk and allocate more memory as needed.

Uses the following code:

char *getln()
{
    char *linha = NULL, *tmp = NULL;
    size_t tamanho = 0, index = 0;
    int ch = EOF;

    while (ch) {
        ch = getc(stdin);

        /* Checamos se devemos parar. */
        if (ch == EOF || ch == '\n')
            ch = 0;

        /* Checamos se devemos expandir. */
        if (tamanho <= index) {
            tamanho += CHUNK;
            tmp = realloc(linha, tamanho);
            if (!tmp) {
                free(linha);
                linha = NULL;
                break;
            }
             linha = tmp;
        }

        /* Finalmente adicionamos o caractere */
        linha[index++] = ch;
    }

    return linha;
}

Remembering that CHUNK is a value appropriate to you. The flawless way is #define CHUNK 1. The method can change the results of time (input much longer).