指向const静态数组的指针

Question

For finite field math I store the corresponding addition and multiplication tables as statically typed integer arrays, eg, for GF(4/8), I have

static const uint8_t GF4ADD[4][4] = {...};

static const uint8_t GF8ADD[8][8] = {...};

Now, at runtime, the program reads from a config file which field size is desired and should assign to a struct pointer the corresponding table:

struct obj data {
...
  uint8_t** table_add;
  uint8_t** table_mult;
...
};

switch(order) {
case 4:
  data.table_add = GF4ADD;
  data.table_mult = GF4MULT;
  break;
case 8:
  data.table_add = GF8ADD;
  data.table_mult = GF8MULT;
  break;
}

Of course, the above doesn't work, but it should give you the idea of what I am trying to accomplish. The main problem is that I don't know of which type I should declare the struct members, as the size of the tables is only known at runtime. Besides, I do not want to resort to a one-dimensional indexing of the tables only.

Thanks, Tom.

Answer 1

You need to declare it as you did, with pointers. After that, when you will get the order , you will be able to allocate dynamically the memory you will need.

---

Simple example 1 (using pointer to pointer):

struct{
    int ** table_add;
}data;


int main()
{
    unsigned int order;
    scanf("%u", &order);
    // create "order" pointers 
    data.table_add = malloc(order * sizeof(int *));
    // where each pointer points to "order" elements
    for(unsigned int i = 0; i < order; i++)
        data.table_add[i] = malloc(order * sizeof(int));

    // fill with numbers
    int counter = 0;
    for(unsigned int i = 0; i < order; i++)
        for(unsigned int j = 0; j < order; j++)
            data.table_add[i][j] = counter++;

    // read result
    for(unsigned int i = 0; i < order; i++){
        for(unsigned int j = 0; j < order; j++)
            printf("%d ",data.table_add[i][j]);
        printf("\n");
    }
    return 0;
}

---

Simple example 2 (allocating 2D array):

replace the start of the 1st example with:

    ...
    unsigned int order;
    scanf("%u", &order);
    // allocate memory for a 2D array
    data.table_add = malloc(sizeof(int[order][order]);
    // fill with numbers 
    ...

As @Lundin mentioned, this way is more efficient. The reasons for this are 3 as I see it:

1. Size - no need to allocate memory for pointers (saves order * sizeof(int*) )
2. Time - one call to malloc instead of order + 1
3. Simpler code (less mallocs --> less frees --> less errors)

---

In your case, you will need to fill the elements in a loop (looping over each element and assigning them, or looping over order elements and using memcpy )