Динамически растущий массив на основе пользовательского ввода в C

Question

Мне нужно создать программу, которая:

1. изначально выделяет массив для чтения и поддерживает до 5 температур.
2. предлагает пользователю ввести температуры и ввести значение -100.0 после их завершения
3. , если пользователь заполняет массив, ваша программа должна динамически выделить новый массив, размер которого в два раза больше.
4. скопировать старые значения в новый массив.освободить старый массив.
5. продолжить чтение в новый массив.
6. распечатать новый массив, когда он будет готов

Я совершенно новичок вС и я вроде застрял.Я знаю, как создать динамический массив, но я не знаю, как создать новый массив, который постоянно увеличивается после заполнения старого массива.

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

int main(void){
    int i,k; //loop count
    int j = 5; //initial array size
    int* temp = malloc(sizeof(int)*j); 
    int* newtemp;

    for (i = 0; i < j; i++){ //loop to read in temperature
        printf("enter temperature: ");
        scanf("%d",(temp+i));
        if (i=j){
        j = j*2; //double the size of initial array
        int* newtemp = malloc(sizeof(int)*j);
        strcpy(*newtemp,temp); // copy string
        for (k = 0; k < j; k++){ //loop to read in temperature
            printf("enter temperature: ");
            scanf("%d",(temp+i+k));
            }
        }
        switch (temp[i]){
            case (-100):
            temp[i] = '\0';
            i = 5; //loop ends
            break;
        }    
    }
    return 0;
}

Сообщения об ошибках:

tempp.c:18:16: warning: passing argument 1 of ‘strcpy’ makes pointer from integer without a cast [-Wint-conversion]
         strcpy(*newtemp,temp);
                ^
In file included from tempp.c:3:0:
/usr/include/string.h:121:14: note: expected ‘char * restrict’ but argument is of type ‘int’
 extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
              ^~~~~~
tempp.c:18:25: warning: passing argument 2 of ‘strcpy’ from incompatible pointer type [-Wincompatible-pointer-types]
         strcpy(*newtemp,temp);
                         ^~~~
In file included from tempp.c:3:0:
/usr/include/string.h:121:14: note: expected ‘const char * restrict’ but argument is of type ‘int *’
 extern char *strcpy (char *__restrict __dest, const char *__restrict __src)

Я знаю, что мой код грязный, и я действительно не знаю правильного метода перераспределения нового массива, пока он постоянно растет.Пожалуйста, помогите мне с этим.Спасибо!

Answer 1

Как насчет использования инструмента realloc?

void printArray(double *array, int size){
    for(int i=0; i<size; i++){
        printf("%.1lf ", array[i]);
    }
    putchar('\n');
}

int main(void){
    int size = 5;
    double *array = malloc(size * sizeof(double)); 
    double temperature;
    int i = 0;

    while(1){
        if(temperature == -100.0)
            break;
        if(i == size){
            size *= 2;
            array = realloc(array, size * sizeof(double));
        }
        scanf("%lf", &temperature);
        array[i] = temperature;
        printArray(array, size);
        i++;
    }
    free(array);
    return 0;
}

Answer 2

Вы можете попытаться объявить два массива и переключаться между ними следующим образом:

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

int main(void){

    int currentArraySize = 5;

    int* temperatures1 = malloc(sizeof(int)*currentArraySize);
    int* temperatures2 = NULL;
    int temperaturesSlot = 0;
    int temperature = 0;
    int index = 0;


    while(1){
        if (index == currentArraySize){
            switch (temperaturesSlot){
                case 0:
                    temperatures2 = malloc(sizeof(int)* 2 *currentArraySize);
                    memcpy(temperatures2, temperatures1, currentArraySize * sizeof(int));
                    free(temperatures1);
                    temperatures1 = NULL;
                    temperaturesSlot = 1;
                    break;
                case 1:
                    temperatures1 = malloc(sizeof(int)* 2 *currentArraySize);
                    memcpy(temperatures1, temperatures2, currentArraySize * sizeof(int));
                    free(temperatures2);
                    temperatures2 = NULL;
                    temperaturesSlot = 0;
                    break;
            }
            currentArraySize *= 2;
        }

        printf("enter temperature: ");
        scanf("%d",(&temperature));
        if (temperature == -100){
            break;
        }
        else if (temperaturesSlot == 0){
            temperatures1[index] = temperature;
        }
        else{
            temperatures2[index] = temperature;
        }
        ++index;
    }

    for (int i = 0; i < index; ++i){
        if (temperaturesSlot == 0){
            printf("%d, ", temperatures1[i]);
        }
        else{
            printf("%d, ", temperatures2[i]);
        }
    }
}

Answer 3

#define INITIALSIZE 5

typedef struct 
{
    size_t size;
    size_t index;
    int data[];
}DATA_t;

DATA_t *addData(DATA_t *data, int val)
{
    if(!data)
    {
        data = malloc(INITIALSIZE * sizeof(data -> data[0]) + sizeof(*data));
        /* malloc result checks */
        data -> size = 0;
        data -> index = 0;
    }
    if((data -> index + 1) == data -> size)
    {
        size_t newsize = data -> size * 2 ;
        DATA_t *newdata = malloc(newsize * sizeof(data -> data[0]) + sizeof(*data));
        /* malloc result checks */
        memcpy(newdata, data, data -> size * sizeof(data -> data[0]) + sizeof(*data));
        newdata -> size = newsize;
        free(data);
        data = newdata;
    }
    data -> data[data -> index++] = val;
    return data;
}

использование:

DATA_t *mydata = NULL;

while(condition)
{
    mydata = addData(mydata, ReadValue());
    /* ----- */
}