C pointeur au tableau d'entiers d'entiers

Assumer la syntaxe est le problème ici (et non des performances), vous pouvez essayer de créer ceci à partir de zéro.

Dans les deux cas, la syntaxe est légèrement plus compliquée que dans votre code JavaScript. Je ne suis pas sûr de combien de fois plus courte peut faire cela en C, mais vous pourriez probablement en rendre un peu plus facile à lire en C ++. P>

Néanmoins, je fournis 2 approches ci-dessous. Soit en utilisant des arguments variables pour gérer la création de tableaux plus petits ou en analysant un éventail de chaînes, ce qui est sans doute plus facile à lire, mais probablement un peu plus lentement. P>

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

// I don't know what type you had in mind...
typedef int type_t;
#define type_t_specifier "%d"

typedef struct tab { // Helper struct
    type_t* data;
    size_t size;
} tab;

tab ctb(size_t size, ...) { // Parse one of the subarrays into the temporary struct
    tab res;
    res.size = size;
    res.data = (type_t*)malloc(res.size * sizeof(type_t));
    va_list valist;
    va_start(valist, size);
    for (int i = 0; i < size; i++) {
        res.data[i] = va_arg(valist, int);
    }
    return res;
}

typedef struct array_t { // Array struct
    type_t** data;
    size_t* sizes;
} array_t;

array_t create_array1(size_t size, ...) { // Create the array using variable arguments
    array_t array;
    array.data = (type_t**)malloc(size * sizeof(type_t*));
    array.sizes = (size_t*)malloc((size + 1) * sizeof(size_t));
    array.sizes[0] = size;
    va_list valist;
    va_start(valist, size);
    for (int i = 0; i < size; i++) {
        tab temp = va_arg(valist, tab);
        array.data[i] = (type_t*)malloc(temp.size * sizeof(type_t));
        array.sizes[i + 1] = temp.size;
        array.data[i] = temp.data;
    }
    return array;
}

array_t create_array2(size_t size, const unsigned char** temp) { // Or you can simply parse an array of strings instead
    array_t array;
    array.data = (type_t**)malloc(size * sizeof(type_t*));
    array.sizes = (size_t*)malloc((size + 1) * sizeof(size_t));
    array.sizes[0] = size;
    for (int i = 0; i < size; i++) {
        int nsize = 1;
        for (int j = 0; temp[i][j] != '\0'; j++) {
            if (temp[i][j] == ',') {
                nsize++;
            }
        }
        array.data[i] = (type_t*)malloc(nsize * sizeof(type_t));
        array.sizes[i + 1] = nsize;
        int start = 0;
        int cnt = 0;
        for (int j = 0; j <= strlen(temp[i]); j++) {
            if (temp[i][j] == ',' || temp[i][j] == '\0') {
                sscanf(&(temp[i][start]), type_t_specifier, &array.data[i][cnt++]);
                start = j + 1;
            }
        }
    }
    return array;
}

void delete_array(array_t array) { // Clean up the array
    for (int i = 0; i < array.sizes[0]; i++) {
        free(array.data[i]);
    }
    free(array.data);
    free(array.sizes);
}

void print_array(array_t array) { // Just to check if it works
    for (int i = 0; i < array.sizes[0]; i++) {
        for (int j = 0; j < array.sizes[i + 1]; j++) {
            fprintf(stderr, type_t_specifier, array.data[i][j]);
            if (j != array.sizes[i + 1] - 1) fprintf(stderr, " ");
            else fprintf(stderr, "\n");
        }
    }
}

int main(void) {
    array_t myarray;
    // You can either complicate the syntax a tiny bit by providing the lengths of each of the subarrays
    myarray = create_array1(4, ctb(4, 1, 2, 3, 4), ctb(2, 123, 234), ctb(1, 1), ctb(2, 1, 2));
    print_array(myarray);
    delete_array(myarray);
    // Or parse an array of strings to create your array
    const unsigned char* temp[] = { "1,2,3,4", "123,234", "1", "1,2" };
    myarray = create_array2(4, temp);
    print_array(myarray);
    delete_array(myarray);
    return 0;
}
// We need to parse the size of the outer array in both cases.