Dynamic allocation of vectors

Question

Follows the statement:

Make a program that reads keyboard numbers and store them on one dynamically allocated array. The user will type in a sequence of numbers, no quantity limit. The numbers will be typed one by one and, if he wishes to close the data entry, he will enter the ZERO number. The data must be stored in the memory of this way

• Start with a dynamically allocated size 10 vector;
• Apos, if the allocated vector is full, allocate a new vector of the previous vector size by adding space for another 10 values (size N+10, where N starts with 10);
• Copy the values already typed from the initial area to this larger area and free the initial area memory;
• Repeat this procedure to expand dynamically with another 10 values the allocated vector each time it is full. So the vector will be 'expanded' by 10 values.

At final, display the read vector. Do not use the REALLOC function.

I’m pretty new yet, so there’s probably a lot of things wrong with my code.

I tried to use a second vector, pass everything to it, allocate 10 more spaces in the main vector and then pass it all on to it again.

However, when I type I get to 19 and the program stops. In the first 10, it works perfectly, but then when I allocate another 10 (in case the vector would have 20 spaces) it doesn’t work.

Follow the code I made:

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

int main(){
    int *vet, c=1, c2=0, *vet1, aux;

    vet =(int*) calloc(10, sizeof(int));

    do {
        scanf("%d", &aux);

        if (c == 10){

            vet1 = (int*) malloc (c2 * sizeof(int));

            for (int i=0; i<c2+1; i++) vet1[i] = vet[i];    

            vet = (int*) malloc (c2 * sizeof(int));

            for (int i=0; i<c2; i++) vet[i] = vet1[i];

            c = 1;
        }

        c++;
        c2++;
        vet[c2] = aux;

    } while (aux != 0);

    printf("\n\n")    ;
    for (int i=0; i<c2; i++) printf("%d  ", vet[i]);

    system("pause");
    return 0;
}

Answer 1

One of the reasons for the confusion is that code uses variable names that are difficult to understand what they mean. With better names one can follow better what is happening. The code does more than it should and falls into some traps.

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

int main() {
    int indice = 0, indiceParcial = 0;
    int *vetor = malloc(sizeof(int) * 10);
    while (1) {
        int valor;
        scanf("%d", &valor);
        if (valor == 0) break;
        vetor[indice++] = valor;
        if (indiceParcial++ == 9) {
            int *vetorAuxiliar = malloc(sizeof(int) * (indice + 10));
            memcpy(vetorAuxiliar, vetor, indice * sizeof(int));
            free(vetor);
            vetor = vetorAuxiliar;
            indiceParcial = 0;
        }
    }
    printf("\n");
    for (int i = 0; i < indice; i++) printf("%d  ", vetor[i]);
}

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

• Only declare the variable when you need it
• You don’t need the calloc() and should not do cast of the result.
• I’m not worried about the test to see if the allocation spoke because in exercise like this will not fail
• This is a typical endless loop since the output is in his brain has no reason to use condition
• Once the value is entered you must determine whether to continue or exit the loop
• The first thing that must operate is the addition of the value in the vector
• Then analyze whether the vector has filled and should perform a relocation and copy
• When to recreate you create based on the current size plus 10, as stated
• And use memcpy() which is ready and reliable function to copy data. It uses the sizeof in it for the same reason as in malloc(), these functions operate on the basis of char, then byte copy per byte, and if you have a number of elements of a multibyte type you need to multiply by that number
• You can’t forget to release the memory of the previous vector
• And then we adopt the new vector created as the standard by copying its address (vetor becomes null after the free(), if all goes well)
• And we reset the partial index you control when you break the limit. It is possible to delete this variable and make a indice % 10, but it is almost certain that it will be slower since the division is with large margin the slower operation of the processor. Or use one thing or another, you need to decide if you want simpler code or more performance
• Maybe you should wear one for reducing scope of 2 variables.

Answer 2

Following your style...

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

int main(){
    int *vet, c=0, c2=0, *vet1, aux, N=1;

    vet =(int*) calloc(10, sizeof(int));

    do {

        scanf("%d", &aux);
        if(!aux) break;

        if (c%10 == 0){
            N++;
            vet1 = (int*) malloc (N*10 * sizeof(int));
            for (int i=0; i<(10*(N-1)); i++) vet1[i] = vet[i];    
            free(vet);
            vet = (int*) malloc (N*10 * sizeof(int));
            for (int i=0; i<(10*(N-1)); i++) vet[i] = vet1[i];
            free(vet1);
        }
        c2++;
        vet[c++] = aux;
    } while (aux);

    printf("\n\n");
    for (int i=0; i<c2; i++) printf("%d  ", vet[i]);
    printf("\n");
    free(vet1);
    free(vet);

    return 0;
}