объект переменного размера не может быть инициализирован

Question

Я получаю ошибку variable sized object may not be initialized и не понимаю, почему.

Может кто-нибудь показать мне, как исправить эту строку?

int arr[size] = (int *)(augs->one);

Вот мой код:

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <pthread.h>
#include <assert.h>

int count = 0;

int cmpfunc(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

struct structure {
    int two;
    int *one;
};

void *sort(void *augments) {
    struct structure *augs = (struct structure*)augments;

    int i = 0;
    int size = 1;
    size = augs->two;

    int arr[size] = (int *)(augs->one);
    //int *arr = (int *)data;
    //printf("sizeof:%d\n", sizeof(arr));

    qsort(arr, size, sizeof(int), cmpfunc);
    printf("finaloutput:\n");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }

    printf("\n");
    return NULL;
}

int main(int argc, char *argv[]) {
    FILE *myFile;
    myFile = fopen("data.txt", "r");
    // number of lines in file
    char charicter;

    for (charicter = getc(myFile); charicter != EOF; charicter = getc(myFile)) {
        if (charicter == '\n') {
            count++;
        }
    }

    printf("count is %d\n", count);

    int numberArray[count];
    int i = 0;

    if ((myFile = fopen("data.txt", "r"))) {
        while ((fscanf(myFile, "%d", &numberArray[i]) != EOF)) {
            ++i;
        }
        fclose(myFile);
    }

    assert(argv[1] != NULL);
    int num = atoi(argv[1]); //num equals number input
    int arrayarray[num - 1][(count / num)];
    int idx;

    for (i = 0; i < (count); i++) {
        printf("numberarray[%d]= %d\n", i, numberArray[i] /*[0],numberArray[i][1]*/);
    }

    for (i = 1; i < num + 1; i++) {
        for (idx = 0; idx < (count / num); idx++) {
            arrayarray[i - 1][idx] = numberArray[i * idx];
        }
    }

    ///*
    for (i = 0; i < ((count / num)); i++) {
        printf("arrayarray[0]=%d\n", arrayarray[0][i]);
    }
    //*/

    int lastarray[((count / num) + (count % num))];
    for (idx = 0; idx < ((count / num) + (count % num)); idx++) {
        lastarray[idx] = numberArray[idx + ((count / num) * (num - 1))];
    }

    for (i = 0; i < ((((count / num) + (count % num)))); i++) {
        printf("lastaray[%d]=%d\n", i, lastarray[i]);
    }
    //*******************
    pthread_t thread_id_arr[num];

    for (i = 0; i < num; i++) {
        pthread_t tid;
        struct structure *augs;

        if (i != (num - 1)) {
            augs = malloc(sizeof(struct structure) + sizeof(int) + sizeof(int) * num);
            (*augs).one = arrayarray[i];
            (*augs).two = (count / num);

            pthread_create(&tid, NULL, sort, augs);
        } else {
            (*augs).one = lastarray;
            (*augs).two = (count / num) + (count % num);

            pthread_create(&tid, NULL, sort, augs);
            //pthread_create(&tid, NULL, sort, (void*)lastarray);
        }

        thread_id_arr[i] = tid;
    }

    for (i = 0; i < num; i++) {
        pthread_join(thread_id_arr[i], NULL);
    }

    return 0;
}

Answer 1

Как отмечали другие, вы не можете инициализировать массив переменной длины указателем, как вы это делаете.Тем не менее, вам вообще не нужен VLA.Используйте это вместо:

int *arr = augs -> one;

Вы хотите воздействовать непосредственно на массив, который передается в поток, а не делать его копию.

При этом я вижу еще одну проблему.В цикле, который порождает потоки сортировки, вы не выделяете новый args на последней итерации цикла, он повторно использует выделенный args от предыдущей итерации, что может вызвать аварию для потока со второго по последний.Вам нужно переместить вызов malloc() выше if.

Кроме того, malloc() выделяет больше памяти, чем фактически используют ваши потоки.Вам нужно всего лишь выделить достаточно памяти для самой структуры, а не для любых целых чисел, следующих за структурой.

Кроме того, когда каждый поток выполняется с использованием выделенного args, которое ему дано, ему необходимо free() args, чтобы избежать утечки памяти.