C 指向整数数组数组的指针

Question

What is the equivalent in C for inizializing a (constant) array of arrays of integers (of different dimensions) ?

In javascript it is like this:

myarray=[ [1,2,3,4], [123,234], [1], [1,2] ]

 console.log(myarray=[ [1,2,3,4], [123,234], [1], [1,2] ])

How do I do the same in C?

Example: This in C works:

const unsigned char *cf[] = { "\x2", "\x0,\x1,\x2", "\x3,\x4"};

I wish to do the same but without the quotes.

putting directly 2, [0,1,2], [3,4]

I explain better:

this works:

int c1[]={1,2,3,4};
int c2[]={5,6};
int c3[]={2,3,4}

int *arr[]={c1,c2,c3};

so I can access every element as arr[0][x] arr[1][x]

now i have a big array. how can I initialize it?

Answer 1

const unsigned char *cf[] = { "\x2", "\x0,\x1,\x2", "\x3,\x4"};

I wish to do the same but without the quotes.

---

Code could use compound literals to form the small unsigned char arrays. Yet cf[] (an array of pointers to unsigned char ) loses knowledge of how big each array.

Not quite an "array of arrays of integers of different dimensions".

int foo() {
  const unsigned char *cf[] = {
      (unsigned char[]) { 2, ',', 0 }, 
      (unsigned char[]) { 0, ',', 1, ',', 2, 0 }, 
      (unsigned char[]) { 3, ',', 4, 0 }
  };
  return cf[0][0];
}

---

Note: "\\x2" is 2 bytes long.
"\\x0,\\x1,\\x2" is 6 bytes long.
"\\x3,\\x4" is 4 bytes long.

`

Answer 2

What is the equivalent in C...

The short answer is there is nothing equivalent in C for doing what you are showing in javascript .

The most common way to do something similar in C is to use a struct:

typedef struct {
   int a[4];
   int b[2];
   int c[1];
   int d[2];
} ARR;

const ARR arr = {{1,2,3,4}, {123, 234}, {1}, {1,2}};

C99 (and beyond) implements flexible array members . This is similar, but again, not exactly what you want. ( ie it also uses the struct construct.)

Answer 3

There's no easy way to do it and it depends if you know exactly your input.

What I did was to store N + 1 size for the int *nums and then store the total length in the first memory position.

#include <stdio.h>
#include <stdlib.h>
#define SIZE_ARRAY 4

struct myArray{
  int *nums;  
};

int main()
{
    struct myArray myArrays[SIZE_ARRAY];
    myArrays[0].nums = malloc(sizeof(int) * 5);
    *(myArrays[0].nums) = 4;//the size of the allocated memory
    *(myArrays[0].nums + 1) = 1;
    *(myArrays[0].nums + 2) = 2;
    *(myArrays[0].nums + 3) = 3;
    *(myArrays[0].nums + 4) = 4;

    myArrays[1].nums = malloc(sizeof(int) * 3);
    *(myArrays[1].nums) = 2;//the size of the allocated memory
    *(myArrays[1].nums + 1) = 123;
    *(myArrays[1].nums + 2) = 234;

    myArrays[2].nums = malloc(sizeof(int) * 2);
    *(myArrays[2].nums) = 1;//the size of the allocated memory
    *(myArrays[2].nums + 1) = 1;

    myArrays[3].nums = malloc(sizeof(int) * 3);
    *(myArrays[3].nums) = 2;//the size of the allocated memory
    *(myArrays[3].nums + 1) = 1;
    *(myArrays[3].nums + 2) = 2;

    printf("[");
    for(int i = 0; i < SIZE_ARRAY; ++i)
    {
        printf("[");
        for (int j = 0; j < *(myArrays[i].nums); ++j)
        {
            printf("%d", *(myArrays[i].nums + j + 1));

            if (j < *(myArrays[i].nums) - 1)
            {
                printf(", ");
            }
        }

        printf("]");

        if (i < SIZE_ARRAY - 1)
        {
            printf(", ");
        }
    }
    printf("]");

    return 0;
}

It gives the expected output but it's not as flexible as the javascript code.

Answer 4

The difficulty in C is that there is no in-built data type that stores a heterogeneous list of elements. But of course, C being C, you can build something up yourself using pointers and structs, like my example below. The nasty implementation detail is that you need some way to store the size of each of your arrays, hence the need for a struct.

#include <stdio.h>

typedef struct container_t
{
  int size;
  int *item;
} container_t;

int main(void)
{  
  int a[] = {1,2,3,4};
  int b[] = {123,234};
  int c[] = {1};
  int d[] = {1,2};
  container_t s[] = {
                      {sizeof(a)/sizeof(a[0]), a},
                      {sizeof(b)/sizeof(b[0]), b},
                      {sizeof(c)/sizeof(c[0]), c},
                      {sizeof(d)/sizeof(d[0]), d}
                    };

  for(int i = 0; i < sizeof(s)/sizeof(s[0]); i++)
  {    
    printf("[");
    for(int j = 0; j < s[i].size; j++)
      printf("%d,", s[i].item[j]);
    printf("]\r\n");
  }
}

Output:

[1,2,3,4,]

[123,234,]

[1,]

[1,2,]

Answer 5

Assuming syntax is the issue here (and not performance), you could try to create this from scratch.

In both cases the syntax is slightly more complicated than in your Javascript code. I'm not sure how much shorter one can make this in C, but you could probably make it a bit easier to read in C++.

Still, I provide 2 approaches below. Either by using variable arguments to handle the creation of smaller arrays or by parsing an array of strings, which is arguably even easier to read, but probably a bit slower.

#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.

One way this could be improved for performance would also be to store the memory contiguously. This would make later use faster but probably cost a bit more time when constructing the array.

Or if you wanted to make it even easier to work with you could simply parse your original javascript array. Though I really would avoid parsing strings if possible.