Segmentation Fault

Question

I would like to dynamically allocate memory without informing the amount of elements that a vector would have.

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

int cardinalidade(char *conjunto)
{
    int contador = 0, indice = 0;

    while (1)
    {
        if (conjunto[indice] == ' ') // Se o elemento analisado for ' ' entao este foi o ultimo elemento.
        {
            break; 
        }

    }

    indice++;
    contador++; // Conta o numero de elementos no vetor.

    return contador;
}

 char *criaConjunto()
 {
       char flag = '!', *conjunto;
       int indice = 0;

       while (flag != '@')
       {
           printf("ELEMENTO %i: ", indice + 1);
           scanf("%c", &flag); // Armazeno o valor lido em uma variavel temporária.

           indice++; // Foi lido mais um elemento.

           conjunto = (char *) malloc (sizeof(char) * indice);  // Aloco um vetor de n posições(depende do numero de elementos preenchidos)
           conjunto[indice] = flag; // Coloco o valor lido anteriormente no conjunto.
        }

        conjunto[indice + 1] = ' '; // Ultimo elemento será o elemento indicando o fim do conjunto.

       return conjunto; // Retornando o endereço do primeiro elemento do conjunto
}

int main()
{
    char *A = criaConjunto();

    printf("|A| = %i", cardinalidade(A));

    return 0;
}

Answer 1

As already indicated the correct is to use realloc, that you can go asking for the elements of the form you are already asking for, and increasing the size of the vector as it receives elements.

Embedding in your code would look like this:

char flag = '!', *conjunto = NULL; //o vetor tem de ser inicializado a NULL
int indice = 0;

while (flag != '@')
{
    printf("ELEMENTO %i: ", indice + 1);
    scanf(" %c", &flag);
    //     ^--- este espaço antes serve para consumir a quebra de linha

    conjunto = (char *) realloc (conjunto, sizeof(char) * (indice + 1)); //realloc aqui
    conjunto[indice] = flag;
    indice++;//incremento tem de vir no fim senão o 1 elemento vai para a posição 1 e não 0
}

In the realloc is indicated which vector is to be reallocated, which in the example is the conjunto, and to what size it will be relocated. The first time the realloc is called with the vector NULL, and in that case behaves as a malloc. Notice I had to change the increment of indice to the end of while to ensure that the first element is stored in the position 0, but keeping the allocation to the correct size, which is indice + 1.

Failed to assign the end of the string with the correct terminator \0, and ensure there is room for it. Since according to your algorithm also wants to put a space, then you can do so:

//+2 => reservaço tamanho para o espaço e terminador
conjunto = (char *) realloc (NULL, sizeof(char) * (indice + 2)); 
conjunto[indice++] = ' '; 
conjunto[indice] = '\0'; //coloca o terminador no fim

With the terminator you can already print the vector in a printf, if you so wish.

Just as a final note, notice that you have a while effectively infinite in function cardinalidade:

while (1)
{
    if (conjunto[indice] == ' ') // Se o elemento analisado for ' ' entao este foi o ultimo elemento.
    {
        break; 
    }
}

Like the indice is not increasing, this while It will never end, because it never leaves the same character. Besides, there’s no count in there that’s what I suspect I wanted to do.