Thread: Array Pointers error

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

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)

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.

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.

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

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.

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?