Array Pointers error

Quote:

---

Originally Posted by taurus

well yea i get the error:
multi.c:10: warning: assignment from incompatible pointer type

I thought since its a 2D array i need a pointer to a pointer

---

In C, many warnings are actually errors.
And a good programmer never ever ignores a warning. A good programmer writes code in such a way that it does not create warnings, hence making it more "correct" (don't just silence warnings).

Quote:

---

Originally Posted by taurus

PS: u said int** ptr. Is that the same as int **ptr?
thanks

---

Yes!
http://www.research.att.com/~bs/bs_faq2.html#whitespace

But just think of it this way:
The compiler use a formula to calculate an offset to read/write to/from in an array.
This formula looks like: inner_n * outer_size * sizeof(array_type) + outer_n * sizeof(array_type), where inner_n is the element you wish to access in the first dimension and outer_n the same, but for the outer dimension.
An example:

int n[10][20];
n[5][6] = 1;

The formula becomes:
inner_n = 5
outer_size = 20
outer_n = 6
5 (inner_n) * 20 (outer size) * sizeof(int) + 6 (outer_n) * sizeof(int)

...But if you pass a ptp (pointer to pointer), the formula becomes:

int** n;
n[5][6] = 1;

Formula:
inner_n = 5
outer_size = ?
outer_n = 6
5 * ? * sizeof(int) * 6 * sizeof(int)

As you can see, a variable is missing and therefore the calculation cannot be done.
Therefore, a 2D array is not a ptp, it is instead a pointer which incorporate the size of the outer dimension:
int (*n)[20];
n[5][6] = 1;

inner_n = 5
outer_size = 20
outer_n = 6
5 * 20 * sizeof(int) + 6 * sizeof(int)

But if you look at the code on the previous page whats wrong with it?

The code is horribly wrong and crashes, and you should get several warnings, if not errors.
First error is:

Code:

---

function(array, 4);

---

array is not a ptp, it is a 2D array, and should NOT be passed as a ptp.
Because arrays are contiguous, it's one big block of memory and the compiler uses the formula I outlined below. Therefore, if anything, it should be a pointer to int, only.

The second and most horrifying blunder is:

Code:

---

ptr = array[0][0];

---

You assign the value of the element 0, 0 to the pointer, which is 1. And 1 is not a valid address!
Anything after this is guaranteed to go horrible and utterly wrong.

Secondly, this part:

Code:

---

printf("%d\n", *(*(ptr + i) + j) );

---

The value you're trying to get is horribly wrong, too, because you dereference twice. There are no pointers stored in the array, so you'll dereference a value and get a faulty memory address.

Yea i do, but i dont know how to fix that given that I have to use the function declaration as seen with then **array

What do i change?

You should understand that. It has already been explained how to pass a 2D array. Start with that.
Then print the array as you would a local array.

Ok ummm
since my function is
void function(int **array, int num)

That means array is a pointer to a pointer correct?

so to pass an array to that i need to pass a pointer to a pointer to my array?

If you can change that function, then do it. Use a proper type to pass the 2D array.
You've been given several examples.
Otherwise you need to pass the address of a pointer (or several), that finally points to your array.

Code:

---

#include <stdio.h>
void function(int **array, int num)
{
        int i, j;
        for(i=0; i<=1; i++)
        {
                for(j=0; j<=3; j++)
                {
                        printf("&#37;d\n", array[i][j]);
                }
        }
}

int main(void)
{
        int i, j;

        int array[2][4] = {{1,2,3,4}, {5,6,7,8}};
        function(&array, 4);       
}

---

I did that but still doesnt seem to be happy with the passing of the array?

Whoops! I was looking at the wrong page...anyway...

Again, your use of a pointer to point to a pointer inside "function" is superfluous. I noticed that the rules governing char's and int's are slightly different here:

Code:

---

#include <stdio.h>
void function(int (*array)[4])
        {
                int i, j;
                for(i=0; i<=1; i++)
                {
                        for(j=0; j<=3; j++)
                        {
                                printf("&#37;d\n", array[i][j] );
                        }
                }
        }

void funchar(char **array)
        {
                int i, j;
                for(i=0; i<=1; i++)
                {
                        for(j=0; j<=3; j++)
                        {
                                printf("%c\n", array[i][j] );
                        }
                }
}

int main(void)
{
        int i, j;
        char *ray[2] = {"this","that"};
        int array[2][4] = {{11,22,33,44}, {55,66,77,88}};
        function(array);       
        funchar(ray);       
}

---

Output:
11
22
33
44
55
66
77
88
t
h
i
s
t
h
a
t

But iv been given a question in which i have to use the void function(int **array, int num)
So with that in mind what do i do

Since T* is what you get what you take the address of T, then to get T**, you would need to take the address of T*. What do you get when you take the address of a 2D-array?
You get T* (*)[inner_size][outer_size], so no, that is horribly incorrect.

However, what you can do is use the dynamic approach of creating a 2D array.
First you create an array of pointers.
Each of those pointers will pointer to an element.
That way you get T** for the basic array, T* for each pointer to T, and T for each element.

It may be difficult, but if you can crack this nut with the information given, then you should become a good programmer.

hmm so you mean something like this:

Code:

---

nt main(void)
{
        int i, j;
        int (*ptr)[2];
        ptr[4] = {{1,2,3,4}, {5,6,7,8}};
        function(ptr);       
}

---

yep true, pointers are the hardest part i heard, so i hope i can crack this, persistence should pay off i hope

Quote:

---

Originally Posted by taurus

hmm so you mean something like this:

Code:

---

nt main(void)
{
        int i, j;
        int (*ptr)[2];
        ptr[4] = {{1,2,3,4}, {5,6,7,8}};
        function(ptr);       
}

---

yep true, pointers are the hardest part i heard, so i hope i can crack this, persistence should pay off i hope

---

We mean something maybe a little bit like that. For sure, malloc will be involved. To get an m x n array, your **array would have to hold m single-star pointers; and then each single-star pointer will have to hold n integers.

Try to think visually!
Perhaps this might be of a little help: http://cboard.cprogramming.com/showp...3&postcount=31
Remember that ptp is an address of a pointer to T.

Code:

---

int x;
int* p = &x;
int** p2 = &p;

---

Armed with this knowledge, perhaps it will become easier?

Ill have a read thanks, its a lot clearer now then at the start of the day