Передача трёхмерного массива в pthread_create

#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
 
void generate (int ***array){ /*функция для заполнения и вывода массива*/
        for (int i=0; i<10; i++){
                for(int j=0; j<3; j++){
                        for(int k=0; k<11; k++){
                                array[i][j][k]=rand()%100;
                        }
                }
        }
        for (int i=0; i<10; i++){
                for(int j=0; j<3; j++){
                        for(int k=0; k<11; k++){
                                printf("%d ", array[i][j][k]);
                        }
                        printf("\n");
                }
                printf("\n\n\n");
        }
 
}
 
void programm(int ***array){ /*считаем чётные и нечётные элементы в каждой строке*/
    int chet=0, nechet=0;
    for (int i=0; i<10; i++){
        for (int j=0; j<3; j++){
            for (int k=0; k<11; k++){
                if (array[i][j][k]%2==0)
                            chet++;
                        else if(array[i][j][k]%2==1)
                                nechet++;
                }
                printf("chet:%d         nechet:%d\n\n", chet, nechet);
                chet=0;
                nechet=0;
        }
    }
}
 
void* pthread(void ***varray){ /*потоковая функция*/
    int ***array= (int***) varray;
    generate(array);
    programm(array);
}
 
int main (){
    int max=10;
    pthread_t pt[max];
    int arr[max][10][11]; /*10 массивов по 10 строк по 11 символов*/
    for (int i=0; i<max; i++){
        pthread_create(pt, NULL, pthread, (void*) arr[i]);
        pthread_join(pt[i], NULL);
    }
}

void* pthread(void *varray){ /*потоковая функция*/
    int ***array= (int***) varray;

pthread_create(&pt[i], ....

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h> /* for bool type */
#include <getopt.h> /* for options support */
#include <pthread.h> /* for pthreads support */
#include <unistd.h> /* for sleep */
 
/* название программы */
#define PROGNAME "threads2"
/* версия программы */
#define VERSION "0.1"
 
int debug;
int errcode = 0; /* код ошибки */
pthread_t tid[100]; /* максимальное количество потоков */
int tcount;
 
int done; /* эта переменная отвечает за то, чтобы главный поток завершился, когда все дочерние потоки отработают */
 
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; /* если потребуется синхронизировать потоки, потребуется это */
 
void *thr_fn(void *arg) {
    int (*aaa)[3][3] = (int (*)[3][3])arg; /* это локализация переменной, чтобы можно было пользоваться как трехмерным массивом */
 
    int i, j, k;
 
    //pthread_mutex_lock(&lock); /* раскомментируй это, если нужно, чтобы потоки друг другу не мешали */
 
        /* тут будут твои вычисления */
        /* это пример */
 
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            for (k = 0; k < 3; k++) {
                printf("%d ", aaa[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
 
    done--;
 
    //pthread_mutex_unlock(&lock);  /* раскомментируй это, если нужно, чтобы потоки друг другу не мешали */
 
        /* поток обязательно должен вернуть указатель. Возвращаем 0 */
    return (void *)0;
}
 
/* функция для распечатки трехмерного массива, для отладки */
void print_aaa(int aaa[3][3][3]) {
    int i, j, k;
 
    i = j = k = 3;
 
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            for (k = 0; k < 3; k++) {
                printf("%d ", aaa[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
}
 
/* вызываем эту функцию, если пользователь ввел некорректные параметры */
void usage(const char * const name)
{
        printf("usage:\n%s [options]\n", name);
        printf("options:\n");
    printf("  --help\t\t\tThis help.\n");
        printf("  -d, --debug\t\t\tPrint lots of debugging information.\n");
        printf("  -V, --version \t\tPrint program version.\n");
}
 
/* наша любимая главная функция, она же точка входа */
int main(int argc, char *argv[])
{
        /* опции, которые принимает программа */
        static struct option long_options[] = {
                {"help", 0, 0, '?'},  /* показать помощь */
                {"debug", 0, 0, 'd'}, /* инициализировать отладку */
                {"version", 0, 0, 'V'}, /* показать версию и выйти */
                {0, 0, 0, 0} /* последняя опция должна быть с нулями */
        };
 
        /* ниже идет штука, которая считывает опции */
        int c, index = 0;
        while((c = getopt_long(argc, argv, "hdV", long_options, &index)) != -1) {
                switch(c) {
        case 'd':
                        debug = true;
                        break;
 
                case ':':
                        printf("Option -%c requires an operand\n", optopt);
                        usage(argv[0]);
                        errcode = -1;
                        goto exit;
 
                case 'V':
                        printf("%s %s\n", PROGNAME, VERSION);
                        printf("Copyright (C) 2010 fish9370");
                        printf("This is free software; see the source for copying conditions.  There is NO\n");
                        printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
                        goto exit;
 
                case '?':
                        /*printf("Unrecognized option: -%c\n", optopt);*/
                        usage(argv[0]);
                        goto exit;
                }
 
    }
 
        /* итак, опции получены, можно запускать полезный код */
 
        /* объявим трехмерный массив и статически инициализируем его */
    int aaa[3][3][3] = {
        {{1,2,3}, {1,2,3}, {1,2,3}},
        {{1,2,3}, {1,2,3}, {1,2,3}},
        {{1,2,3}, {1,2,3}, {1,2,3}},
    };
 
        /* если пользователь ввел опцию -d, распечатаем наш массив */
        if (debug)
            print_aaa(aaa);
 
        /* по умолчанию счетчик done равен нулю, что говорит, не один поток не запущен, можно выходить */
    done = 0;
 
        /* поехали, создаем 10 потоков */
    for (tcount = 0; tcount < 10; tcount++) {
                /* увеличиваем счетчик done, чтобы этот поток нужно было подождать */
        done++;
 
                /* создаем новый поток, он тут же запустит функцию thr_fn и передаст ей наш массив aaa */
        pthread_create(&tid[tcount], NULL, thr_fn, (void *)&aaa);
    }
 
        /* ожидаем пока счетчик done не уменьшится до нуля. Это случится, когда все потоки отработают */
    while(done > 0) {
                /* вставим небольшую задержку, чтобы не грузить процессор в холостую */
                usleep(100);
        }
 
exit:
    return errcode;
}

gcc -O0 -g3 -p -ggdb -Wall -pthread threads2.c -o threads2

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h> /* for bool type */
#include <getopt.h> /* for options support */
#include <pthread.h> /* for pthreads support */
#include <unistd.h> /* for sleep */
 
#define PROGNAME "threads2"
#define VERSION "0.1"
 
/* зададим константы с размерностями */
#define D1 3
#define D2 3
#define D3 7
 
int debug;
int errcode = 0;
pthread_t tid[100];
int tcount;
 
int done;
 
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
/* эту структуру мы будем использовать для передачи в функцию. Во-первых, это удобно. Во-вторых, в функцию thr_fn мы можем передать лишь один параметр, а нам нужно много. Это типа лайвхак */
struct a3 {
    void *aaa; /* указатель типа void на наш массив, перед использованием, мы его должны привести к нужному типу*/
    int d1; /* наша размерность */
    int d2;
    int d3;
};
 
void *thr_fn(void *arg) {
    /* мы знаем, что arg это указатель на struct a3. Делаем приведение */
    struct a3 *a3 = (struct a3*)arg; /* "a3" и "struct a3" это не одно и то же */
 
    /* тут нюанс. Так как a3 это указатель, разыменовывать его нужно через '->' */
    int (*aaa)[a3->d2][a3->d3] = (int (*)[a3->d2][a3->d3])a3->aaa; /* создаем локальную переменную aaa и копируем туда адрес нашего массива */
 
    //pthread_mutex_lock(&lock);
 
    int i, j, k;
    for (i = 0; i < D1; i++) {
        for (j = 0; j < D2; j++) {
            for (k = 0; k < D3; k++) {
                printf("%d ", aaa[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
 
    done--;
 
    //pthread_mutex_unlock(&lock);
 
    return (void *)0;
}
 
void print_aaa(struct a3 a3) {
    /* здесь структура передается статически, для разыменования используем точку */
    int (*aaa)[a3.d2][a3.d3] = a3.aaa; /* создаем локальный указатель и копируем в него адрес нашего массива */
 
    int i, j, k;
    for (i = 0; i < a3.d1; i++) {
        for (j = 0; j < a3.d2; j++) {
            for (k = 0; k < a3.d3; k++) {
                printf("%d ", aaa[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
}
 
/* функция создания трехмерного массива */
void *make_aaa(int d1, int d2, int d3) {
    /* выделяем Память одним блоком, размерностью d1 x d2 x d2, с размером ячейки int */
    int (*res)[d2][d3] = malloc(sizeof(int) * d1 * d2 * d3);
 
    /* инициализируем Память значением k+1 (порядковый номер ячейки) */
    int i, j, k;
    for (i = 0; i < d1; i++) {
        for (j = 0; j < d2; j++) {
            for (k = 0; k < d3; k++) {
                res[i][j][k] = k + 1;
            }
        }
    }
 
    /* функция возвращает указатель типа void, что позволяет компилятору автоматически приводить к нужному типу */
    return (void*)res;
}
 
void usage(const char * const name)
{
        printf("usage:\n%s [options]\n", name);
        printf("options:\n");
    printf("  --help\t\t\tThis help.\n");
        printf("  -d, --debug\t\t\tPrint lots of debugging information.\n");
        printf("  -V, --version \t\tPrint program version.\n");
 
        printf("\nreport bugs to <fish9370@mail.ru>\n");
}
 
int main(int argc, char *argv[])
{
 
        static struct option long_options[] = {
                {"help", 0, 0, '?'},
                {"debug", 0, 0, 'd'},
                {"version", 0, 0, 'V'},
                {0, 0, 0, 0}
        };
 
        int c, index = 0;
        while((c = getopt_long(argc, argv, "hdV", long_options, &index)) != -1) {
                switch(c) {
        case 'd':
                        debug = true;
                        break;
 
                case ':':
                        printf("Option -%c requires an operand\n", optopt);
                        usage(argv[0]);
                        errcode = -1;
                        goto exit;
 
                case 'V':
                        printf("%s %s\n", PROGNAME, VERSION);
                        printf("Copyright (C) 2010 fish9370");
                        printf("This is free software; see the source for copying conditions.  There is NO\n");
                        printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
                        goto exit;
 
                case '?':
                        /*printf("Unrecognized option: -%c\n", optopt);*/
                        usage(argv[0]);
                        goto exit;
                }
 
    }
 
    /* создаем экземпляр нашей структуры и тут же создаем массив, размерностью D1 x D2 x D3 */
    struct a3 a3 = {
        .aaa = make_aaa(D1, D2, D3),
        .d1 = D1,
        .d2 = D2,
        .d3 = D3
    };
 
    if (debug) {
    /* при отладке (ключ -d) печатаем наш массив и выходим. Не забываем освободить память */
        print_aaa(a3);
        free(a3.aaa);
        goto exit;
    }
 
    done = 0;
 
    for (tcount = 0; tcount < 10; tcount++) {
        done++;
        pthread_create(&tid[tcount], NULL, thr_fn, (void *)&a3);
    }
 
    while (done > 0)
        usleep(100);
 
    /* Не забываем освободить Память */
    free(a3.aaa);
 
exit:
    return errcode;
}

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h> /* for bool type */
#include <getopt.h> /* for options support */
#include <pthread.h> /* for pthreads support */
#include <unistd.h> /* for sleep */
 
#define PROGNAME "threads2"
#define VERSION "0.4"
 
int debug;
int errcode = 0;
pthread_t tid[100];
int tcount;
 
int done;
 
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
struct a3 {
    void *aaa;
    int d1;
    int d2;
    int d3;
};
 
void *thr_fn(void *arg) {
    struct a3 *a3 = (struct a3*)arg;
 
    /* теперь локализуем переменную aaa так. Это говорит компилятору: мы имеем трехмерный массив указателей. И значение находится по адресу aaa[адрес1][адрес2][адрес3]-> вон там */
    int ***aaa = a3->aaa;
 
    //pthread_mutex_lock(&lock);
 
    int i, j, k;
    for (i = 0; i < a3->d1; i++) {
        for (j = 0; j < a3->d2; j++) {
            for (k = 0; k < a3->d3; k++) {
             /* хотя эта запись осталась прежней aaa[i][j][k], механика получения значения изменилась */
                printf("%d ", aaa[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
 
    done--;
 
    //pthread_mutex_unlock(&lock);
 
    return (void *)0;
}
 
void print_aaa(struct a3 *a3) {
    /*  мы имеем трехмерный массив указателей */
    int ***aaa = a3->aaa;
 
    int i, j, k;
    for (i = 0; i < a3->d1; i++) {
        for (j = 0; j < a3->d2; j++) {
            for (k = 0; k < a3->d3; k++) {
                printf("%d ", aaa[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
}
 
void make_aaa(struct a3 *a3) {
    /* инициализируем генератор случайных чисел, используем текущее время в секундах (функция time(NULL)). Это позволяет получать числа более случайно (не стоит на это полагаться в криптографических алгоритмах) */
    srand(time(NULL));
 
    /* выберем случайные значения для нашего массива, от 3 до 12 */
    a3->d1 = rand() % 10 + 3;
    a3->d2 = rand() % 10 + 3;
    a3->d3 = rand() % 10 + 3;
 
    /* выделяем память под первую размерность нашего массива */
    int (***res) = malloc(sizeof(int*) * a3->d1);
 
    /* адрес полученного блока будет точкой входа в наш массив, сохраним ее в структуре a3 */
    a3->aaa = res;
 
    int i, j, k;
    for (i = 0; i < a3->d1; i++) {
        /* выделяем память для d2 */
        res[i] = malloc(sizeof(int*) * a3->d2);
        for (j = 0; j < a3->d2; j++) {
            /* выделяем память для d3 */
            res[i][j] = malloc(sizeof(int*) * a3->d3);
            for (k = 0; k < a3->d3; k++) {
                res[i][j][k] = k + 1;
            }
        }
    }
 
     /* struct a3 передается по ссылке, т.е. данные будут записаны туда напрямую. Мы ничего не возвращаем */
 
    return;
}
 
/* функция освобождения памяти. Теперь нужно в цикле пробегать и удалять каждый выделеный блок. Делаем это в обратном порядке, тому как выделяли */
void free_aaa(struct a3 *a3) {
    int ***aaa = a3->aaa;
 
    int i, j;
    for (i = 0; i < a3->d1; i++) {
        for (j = 0; j < a3->d2; j++) {
            free(aaa[i][j]);
        }
        free(aaa[i]);
    }
    free(aaa);
}
 
void usage(const char * const name) {
        printf("usage:\n%s [options]\n", name);
        printf("options:\n");
    printf("  --help\t\t\tThis help.\n");
    printf("  -d, --debug\t\t\tPrint lots of debugging information.\n");
        printf("  -V, --version \t\tPrint program version.\n");
 
        printf("\nreport bugs to <fish9370@mail.ru>\n");
}
 
int main(int argc, char *argv[]) {
        static struct option long_options[] = {
                {"help", 0, 0, '?'},
                {"debug", 0, 0, 'd'},
                {"version", 0, 0, 'V'},
                {0, 0, 0, 0}
        };
 
        int c, index = 0;
        while((c = getopt_long(argc, argv, "hdV", long_options, &index)) != -1) {
                switch(c) {
        case 'd':
                        debug = true;
                        break;
 
                case ':':
                        printf("Option -%c requires an operand\n", optopt);
                        usage(argv[0]);
                        errcode = -1;
                        goto exit;
 
                case 'V':
                        printf("%s %s\n", PROGNAME, VERSION);
                        printf("Copyright (C) 2010 fish9370");
                        printf("This is free software; see the source for copying conditions.  There is NO\n");
                        printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
                        goto exit;
 
                case '?':
                        /*printf("Unrecognized option: -%c\n", optopt);*/
                        usage(argv[0]);
                        goto exit;
                }
 
    }
 
    /* создадим структуру a3 и заполним все ее значения нулями */
    struct a3 a3 = {0};
 
    /* создадим трехмерный массив, и запишем его размерности в a3 */
    make_aaa(&a3);
 
    if (debug) {
        printf("init array: %d x %d x %d\n", a3.d1, a3.d2, a3.d3);
 
        print_aaa(&a3);
        free_aaa(&a3);
        goto exit;
    }
 
    done = 0;
 
    for (tcount = 0; tcount < 10; tcount++) {
        done++;
        pthread_create(&tid[tcount], NULL, thr_fn, (void *)&a3);
    }
 
    while (done > 0)
        usleep(100);
 
    /* не забываем освободить память */
    free_aaa(&a3);
 
exit:
    return errcode;
}