# Create a pointer to two-dimensional array

I need a pointer to a static 2-dimensional array. How is this done?

``````static uint8_t l_matrix[10][20];

void test(){
uint8_t **matrix_ptr = l_matrix; //wrong idea
}
``````

I get all kinds of errors like:

• warning: assignment from incompatible pointer type
• subscripted value is neither array nor pointer
• error: invalid use of flexible array member

16

Here you wanna make a pointer to the first element of the array

``````uint8_t (*matrix_ptr)[20] = l_matrix;
``````

With typedef, this looks cleaner

``````typedef uint8_t array_of_20_uint8_t[20];
array_of_20_uint8_t *matrix_ptr = l_matrix;
``````

Then you can enjoy life again :)

``````matrix_ptr[0][1] = ...;
``````

Beware of the pointer/array world in C, much confusion is around this.

### Edit

Reviewing some of the other answers here, because the comment fields are too short to do there. Multiple alternatives were proposed, but it wasn't shown how they behave. Here is how they do

``````uint8_t (*matrix_ptr)[][20] = l_matrix;
``````

If you fix the error and add the address-of operator `&` like in the following snippet

``````uint8_t (*matrix_ptr)[][20] = &l_matrix;
``````

Then that one creates a pointer to an incomplete array type of elements of type array of 20 uint8_t. Because the pointer is to an array of arrays, you have to access it with

``````(*matrix_ptr)[0][1] = ...;
``````

And because it's a pointer to an incomplete array, you cannot do as a shortcut

``````matrix_ptr[0][0][1] = ...;
``````

Because indexing requires the element type's size to be known (indexing implies an addition of an integer to the pointer, so it won't work with incomplete types). Note that this only works in `C`, because `T[]` and `T[N]` are compatible types. C++ does not have a concept of compatible types, and so it will reject that code, because `T[]` and `T[10]` are different types.

The following alternative doesn't work at all, because the element type of the array, when you view it as a one-dimensional array, is not `uint8_t`, but `uint8_t[20]`

``````uint8_t *matrix_ptr = l_matrix; // fail
``````

The following is a good alternative

``````uint8_t (*matrix_ptr)[10][20] = &l_matrix;
``````

You access it with

``````(*matrix_ptr)[0][1] = ...;
matrix_ptr[0][0][1] = ...; // also possible now
``````

It has the benefit that it preserves the outer dimension's size. So you can apply sizeof on it

``````sizeof (*matrix_ptr) == sizeof(uint8_t) * 10 * 20
``````

There is one other answer that makes use of the fact that items in an array are contiguously stored

``````uint8_t *matrix_ptr = l_matrix[0];
``````

Now, that formally only allows you to access the elements of the first element of the two dimensional array. That is, the following condition hold

``````matrix_ptr[0] = ...; // valid
matrix_ptr[19] = ...; // valid

matrix_ptr[20] = ...; // undefined behavior
matrix_ptr[10*20-1] = ...; // undefined behavior
``````

You will notice it probably works up to `10*20-1`, but if you throw on alias analysis and other aggressive optimizations, some compiler could make an assumption that may break that code. Having said that, i've never encountered a compiler that fails on it (but then again, i've not used that technique in real code), and even the C FAQ has that technique contained (with a warning about its UB'ness), and if you cannot change the array type, this is a last option to save you :)

Tuesday, June 1, 2021

38

Arrays aren't pointers, and in C, a multidimensional array is just an array of arrays. In many contexts, using the name of an array "decays" into a pointer to the first element of that array. That's what happens in both of your print statements. In the first case:

``````printf("Base address of array:%pn",a);
``````

`a` becomes a pointer to the first element of the array - that is, a pointer to the first row of your array. In your case, that means you get a pointer of type `int (*)[2]`.

In the second case:

``````printf("Value at the Base address:%pn",*a);
``````

The same decaying happens, but then you dereference that pointer. That means you dereferenced that `int (*)[2]` pointer to the first row, leaving you with an array again (the first row). That array itself decays into a pointer to its first element, giving you a resulting `int *` pointer (to the first element of the first row).

In both cases the address is the same, since that's how the array is laid out in memory. If we said your 2D array started at address `0`, it would look like this (assuming a 4 byte `int` type):

`````` Address       Value
0            1
4            2
8            3
12            4
``````

The address of the first row and the address of the first element of the first row are both `0`.

Wednesday, July 28, 2021

14

Source Code:
The code will be something like:

``````#include <stdlib.h>

int **array;
array = malloc(nrows * sizeof(int *));
if(array == NULL)
{
fprintf(stderr, "out of memoryn");
/*exit or return*/
}
for(i = 0; i < nrows; i++)
{
array[i] = malloc(ncolumns * sizeof(int));
if(array[i] == NULL)
{
fprintf(stderr, "out of memoryn");
/*exit or return*/
}
}
``````

Concept:

`array` is a pointer-to-pointer-to-int: at the first level, it points to a block of pointers, one for each row. That first-level pointer is the first one to be allocated; it has `nrows` elements, with each element big enough to hold a `pointer-to-int`, or `int *`. If the allocation is successful then fill in the pointers (all `nrows` of them) with a pointer (also obtained from `malloc`) to `ncolumns` number of ints, the storage for that row of the array.

Pictorial Depiction:

It is simple to grasp if you visualize the situation as:

Taking this into account, the sample code could be rewritten as:

``````void permute(int num_permute, int num_term, int** order) {
int x, y;
int term[5];
int* ptr = NULL;

for (y=num_term, x=0; y>0; y--, x++) {
term[x] = y;
}
printf("n");

printf("order%12c", ' ');
for (x=0; x<num_permute; ++x) {
printf(" %2d ", x);
}
printf("n");
for (y=0; y<num_permute; y++) {
ptr = order[y];
memcpy(ptr, term, sizeof(term));

printf("%-5d%12p", y, ptr);
for (x=0; x<num_term; x++) {
printf(" %2d ", ptr[x]);
}
printf("n");
}
}

int main() {
int y, z;
int** x = NULL;
int num_term = 5;
int num_permutation = 5;
int* pchk = NULL;

x = (int**) malloc(num_permutation * sizeof(int*));

for (y=0; y<num_permutation; y++){
x[y] = (int*) malloc(num_term * sizeof(int));
printf("x[%d]: %pn", y, x[y]);
}

permute(num_permutation, num_term, x);

printf("nx:  ");
for(z=0; z<5; z++){
printf(" %2d ", z);
}
printf("n");

for(y=0; y<num_permutation; y++){
pchk = x[y];
printf("%-4d", y);
for(z=0; z<num_term; z++){
printf(" %2d ", pchk[z]);
}
printf("n");
}

for (y=0; y<num_permutation; y++) {
free(x[y]);
}
free(x);

return 0;
}
``````
Sunday, August 15, 2021

88

Let me start off by saying something a little off topic:

• I don't think this is a very good book. I think it confuses some topics to make them seem harder than they really are. For a better advanced C book, I would recommend Deep C Secrets by Peter van der Linden, and for a beginner's book, I'd recommend the original K & R

Anyway, it looks like you're looking at the extra credit exercises from this chapter.

• Another aside- I don't think this is an especially sensible exercise for learning (another answer pointed out the question isn't formed to make sense), so this discussion is going to get a little complex. I would instead recommend the exercises from Chapter 5 of K & R.

First we need to understand that pointers are not the same as arrays. I've expanded on this in another answer here, and I'm going to borrow the same diagram from the C FAQ. Here's what's happening in memory when we declare an array or a pointer:

`````` char a[] = "hello";  // array

+---+---+---+---+---+---+
a: | h | e | l | l | o | |
+---+---+---+---+---+---+

char *p = "world"; // pointer

+-----+     +---+---+---+---+---+---+
p: |  *======> | w | o | r | l | d | |
+-----+     +---+---+---+---+---+---+
``````

So, in the code from the book, when we say:

``````int ages[] = {23, 43, 12, 89, 2};
``````

We get:

``````      +----+----+----+----+---+
ages: | 23 | 43 | 12 | 89 | 2 |
+----+----+----+----+---+
``````

I'm going to use an illegal statement for the purpose of explanation - if we could have said:

``````int *ages = {23, 43, 12, 89, 2}; // The C grammar prohibits initialised array
// declarations being assigned to pointers,
// but I'll get to that
``````

It would have resulted in:

``````      +---+     +----+----+----+----+---+
ages: | *=====> | 23 | 43 | 12 | 89 | 2 |
+---+     +----+----+----+----+---+
``````

Both of these can be accessed the same way later on - the first element "23" can be accessed by `ages[0]`, regardless of whether it's an array or a pointer. So far so good.

However, when we want to get the count we run in to problems. C doesn't know how big arrays are - it only knows how big (in bytes) the variables it knows about are. This means, with the array, you can work out the size by saying:

``````int count = sizeof(ages) / sizeof(int);
``````

or, more safely:

``````int count = sizeof(ages) / sizeof(ages[0]);
``````

In the array case, this says:

``````int count = the number of bytes in (an array of 6 integers) /
the number of bytes in (an integer)
``````

which correctly gives the length of the array. However, for the pointer case, it will read:

``````int count = the number of bytes in (**a pointer**) /
the number of bytes in (an integer)
``````

which is almost certainly not the same as the length of the array. Where pointers to arrays are used, we need to use another method to work out how long the array is. In C, it is normal to either:

• Remember how many elements there were:

``````int *ages = {23, 43, 12, 89, 2}; // Remember you can't actually
// assign like this, see below
int ages_length = 5;
for (i = 0 ; i < ages_length; i++) {
``````
• or, keep a sentinel value (that will never occur as an actual value in the array) to indicate the end of the array:

``````int *ages = {23, 43, 12, 89, 2, -1}; // Remember you can't actually
// assign like this, see below
for (i = 0; ages[i] != -1; i++) {
``````

(this is how strings work, using the special NUL value '' to indicate the end of a string)

Now, remember that I said you can't actually write:

``````    int *ages = {23, 43, 12, 89, 2, -1}; // Illegal
``````

This is because the compiler won't let you assign an implicit array to a pointer. If you REALLY want to, you can write:

``````    int *ages = (int *) (int []) {23, 43, 12, 89, 2, -1}; // Horrible style
``````

But don't, because it is extremely unpleasant to read. For the purposes of this exercise, I would probably write:

``````    int ages_array[] = {23, 43, 12, 89, 2, -1};
int *ages_pointer = ages_array;
``````

Note that the compiler is "decaying" the array name to a pointer to it's first element there - it's as if you had written:

``````    int ages_array[] = {23, 43, 12, 89, 2, -1};
int *ages_pointer = &(ages_array[0]);
``````

However - you can also dynamically allocate the arrays. For this example code, it will become quite wordy, but we can do it as a learning exercise. Instead of writing:

``````int ages[] = {23, 43, 12, 89, 2};
``````

We could allocate the memory using malloc:

``````int *ages = malloc(sizeof(int) * 5); // create enough space for 5 integers
if (ages == NULL) {
/* we're out of memory, print an error and exit */
}
ages[0] = 23;
ages[1] = 43;
ages[2] = 12;
ages[3] = 89;
ages[4] = 2;
``````

Note that we then need to free `ages` when we're done with the memory:

``````free(ages);
``````

Note also that there are a few ways to write the malloc call:

`````` int *ages = malloc(sizeof(int) * 5);
``````

This is clearer to read for a beginner, but generally considered bad style because there are two places you need to change if you change the type of `ages`. Instead, you can write either of:

`````` int *ages = malloc(sizeof(ages[0]) * 5);
int *ages = malloc(sizeof(*ages) * 5);
``````

These statements are equivalent - which you choose is a matter of personal style. I prefer the first one.

One final thing - if we're changing the code over to use arrays, you might look at changing this:

``````int main(int argc, char *argv[]) {
``````

But, you don't need to. The reason why is a little subtle. First, this declaration:

``````char *argv[]
``````

says "there is an array of pointers-to-char called argv". However, the compiler treats arrays in function arguments as a pointer to the first element of the array, so if you write:

``````int main(int argc, char *argv[]) {
``````

The compiler will actually see:

``````int main(int argc, char **argv)
``````

This is also the reason that you can omit the length of the first dimension of a multidimensional array used as a function argument - the compiler won't see it.

Thursday, October 21, 2021

67

Ok, first to understand this, it's important to know that `const` in C doesn't have to do anything with read-only memory. For C, there is no such thing as sections. `const` is merely a contract, it's expressing the intention that something is indeed constant. This means a compiler/linker can place data in a read-only section because the programmer assured it won't change. It doesn't have to, though.

Second, a string literal translates to a constant array of `char`s with `0` implicitly appended. See Peter Schneider's comment here: it is not formally const (so the compiler won't warn you when you take a non-const pointer to it), but it should be.

Combining this, the following code segfaults on my system with gcc on Linux amd64, because `gcc` indeed places the array in a read-only section:

``````#include <stdio.h>

const int myInts[] = {3, 6, 1, 2, 3, 8, 4, 1, 7, 2};

int main(void)
{
printf("First element of array: %in", myInts[0]);
int *myIntsPtr = myInts;
*myIntsPtr = *(myIntsPtr + 1);
printf("First element of array: %in", myInts[0]);
return 0;
}
``````

Note there is also a compiler warning in the line where you take a non-const pointer to the const array.

Btw, the same code will work if you declare the array inside your function with `gcc`, that's because then, the array itself is created on the stack. Still you get the warning, the code is still wrong. It's a technical detail of how C is implemented here. The difference to a string literal is that it is an anonymous object (the char array doesn't have an identifier) and has static storage duration in any case.

edit to explain what a string literal does: The following codes are equivalent:

``````int main(void)
{
const char *foo = "bar";
}
``````

and

``````const char ihavenoname_1[] = {'b', 'a', 'r', 0};

int main(void)
{
const char *foo = ihavenoname_1;
}
``````

So, short story, if you want `gcc` to put data in a read-only section, declare it `const` with static storage duration (outside of a function). Other compilers might behave differently.

Saturday, November 27, 2021

Not the answer you're looking for? Browse other questions tagged :
Share