Printable View
Hi
Whats wrong with the following:
I just try run it and crashed my command promptCode:#include <stdio.h>
int main(void)
{
int **ptr;
int a, b, i, j;
int array[2][4] = {{1,2,3,4}, {5,6,7,8}};
ptr = &array[0][0];
for(i=0; i<=1; i++)
{
for(j=0; j<=3; j++)
{
printf("%d\n", *(*(ptr + i) + j) );
}
}
}
You are calling ptr a pointer to a pointer to an int.
Then, you set it to be a pointer to an int and then try to use it.Code:int **ptr;
Code:ptr = &array[0][0];
What does ptr[0] point at ?
Answer - nothing.
Just because you can use two subscripts on both of them doesn't make them equivalent or freely interchangeable.
> ptr = &array[0][0];
Did you get a warning for this. You should have, and it's a big clue that something is wrong.
Here are a couple of things which should work.
Code:#include <stdio.h>
int main(void)
{
int **ptr;
int a, b, i, j;
int array[2][4] = {{1,2,3,4}, {5,6,7,8}};
int *parr[2] = { array[0], array[1] };
ptr = parr;
for(i=0; i<=1; i++)
{
for(j=0; j<=3; j++)
{
printf("%d\n", *(*(ptr + i) + j) );
}
}
}
#include <stdio.h>
int main(void)
{
int (*ptr)[4];
int a, b, i, j;
int array[2][4] = {{1,2,3,4}, {5,6,7,8}};
ptr = array;
for(i=0; i<=1; i++)
{
for(j=0; j<=3; j++)
{
printf("%d\n", *(*(ptr + i) + j) );
}
}
}
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
so the way i did it:
there is no slight change i can do to it? As what i did seems to make sense at ptr points to array, so it should just access each element onwardsCode:#include <stdio.h>
int main(void)
{
int *ptr;
int a, b, i, j;
int array[2][4] = {{1,2,3,4}, {5,6,7,8}};
ptr = &array[0];
for(i=0; i<=1; i++)
{
for(j=0; j<=3; j++)
{
printf("%d\n", *(*(ptr + i) + j) );
}
}
}
Hmmm i did this: int (*ptr)[4]; and it works fine.
Could you explain what i just did there a bit? Why is it 4 in the brackets?
> Could you explain what i just did there a bit? Why is it 4 in the brackets?
The [4] is the minor dimension of the array you want to point to.
So int arr[2][4][6][8] would have a pointer int (*p)[4][6][8]
Which is also what you would use if you wanted to pass the array to a function, as in
void foo ( int (*p)[4][6][8] );
Which would be called with
foo( arr );
And in case you are wondering, this is not valid:
Remember that you can "convert an array to a pointer" only for one dimension. This is valid:Code:int*** ptr;
int a[10][10][10];
ptr = a;
So in order to point to a 3d dimensional array you would do what you did:Code:int* ptr;
int a[10]
ptr = a;
Now why the first code wouldn't work is a long storyCode:int (*p)[10][10];
int a[10][10][10];
p = a;
Why do you want to use a (seperate) pointer to do this? Your code will be simpler without the unecessary complication:Quote:
Originally Posted by taurus
Also, understand that as with a char array, the name of an int array is implicitly a pointer to it. But you can't really use **array to cycle throught the arrays because it's actually a pointer to an array of pointers:Code:#include <stdio.h>
int main(void)
{
int a, b, i, j;
int array[2][4] = {{1,2,3,4}, {5,6,7,8}};
for(i=0; i<=1; i++)
{
for(j=0; j<=3; j++)
{
printf("%d\n", array[i][j]);
}
}
}
printf("%d\n", **array);
will print the number at array[0][0], but
printf("%d\n", **(array+1));
will print the number at array[1][0] (5). You might want to use different numbers for your experiments because **array+1 will give you 2 -- but this is not array[0][1], it's array[0][0] (1) + 1.
*(array[i]+j) will work as well.
I would guess because it's array[2][4]. This is a version of *(array[i]+j).Quote:
Originally Posted by taurus
C_ntua you said this:
int (*p)[10][10];
int a[10][10][10];
p = a;
Would it make sense then i could do this:
int (*p)[10][10];
int a[10]:
p = a;
and it would be the same thing?
The second is wrong. You have to think the types:
You can convert one dimension. Thus, a [] to a *. So this is valid:Code:int* p; // int*
int** p; //int**
int a[]; //int[]
int a[][]; //int [][]
But not more than one. This in invalid:Code:int* = int[]
int** = int (*)[]
int**** = int (*)[][][]
And this are different:Code:int** = int[][]
hope this helpsCode:int *p[10]; // an array of int*. Thus 10 pointers to int
int (*p)[10]; // one int[]. Thus one pointer to a 1D array with 10 elements
Yea thanks, makes sense a lot more now
One question
say i hae a function to receive a pointer to 2d array
I would first pass the array to the fucntion like this:
function(array);
then the fuction would be:
void function (int **array)
How do i access the elements that have been passed?
is it just like?:
*(*(array + i) + j)
This is a detail that isn't clarified well.
No, you the function would be this void function(int array[10][10]). And you would pass the array as function(array).
Think for a second the difference. You declare a function that takes an array 10x10. Not ANY size array. Now, think that you can ommit ONE dimension size. Thus declare a funciton void function(int array[][10]). But not BOTH. This is invalid: void function(int array[][]).
If you want more in-depth:
Why is it invalid? ThBecause the compiler needs to know one dimension. So you have to clarify these two meaning in your head:
1) array
2) pointers with indexes
An array is declared an array. So a 2d array is a int array[10][10]. An index is used for arrays AND pointers. So if you declare:
int** ptr
then you can use the indexes. So you can do ptr[1][1] for example. And yes that would mean *(*(ptr+1)+1).
If you want to convert a pointer to an array, you have to follow the one dimension thing.
Now, if you declare int array[10][10] and you get a[1][1] this is NOT the same as *(*(a+1)+1). How it is translated depends from the system. Think though why they are not the same.
If you do *(*(a+1)+1), then you need to do a+1, dereference, add 1, derreference.
Couldn't you do instead *(a+10*1+1)? Thus dereference once? If you don't understand how this would work I will explain more.
If you do, then the second method is valid because you KNOW one dimension. That one dimension of a is sized 10. With pointers you don't know dimensions. So this is not valid.
So the array will use the faster method available.
With a pointer to pointer to in you have this in the memory:
p --> p1 p2 p3 p4 ...
p1 --> int11 int21 int31 ....
p2 --> int12 int22 int32 ...
....
So you find what you want indirectly. But an array might not be the same. A 2D array could be like this in the memory. Lets say a 10x10 array:
a --> int1 .... in100.
The first 10 int are on the first row, the second 10 on the second etc etc. If the compiler knows one dimension and you ask for a[2][5] then this is the element *(a+10*2+5)
What is the difference? With an array you have a contiguous space of memory and the elements are accessed faster. With a pointer they are accessed indirectly. Why can not include the size of one dimension? Because it is not needed. If I tell you that I am passing a int a[][10] in a function, then you can calculate the indexes as previously. The difference would be that you wouldn't know the total elements of the array, which are not checked anyways.
Of course this is just an example. How it is implemented I don't know. In any case just remember int** p is not the same as int p[][X]
EDIT: I apologize for the MANY above syntax, grammar, etc mistakes. I am bored to fix them though...
hmmm
but say i am giving a function declaration:
void function(int **array)
and I have to complete it to print out the contents of the array.
I still dont quite get how i can print out the elements?
The following is a little what I am trying:
PS: u said int** ptr. Is that the same as int **ptr?Code:#include <stdio.h>
void function(int **array, int num)
{
int i, j;
int **ptr;
ptr = array[0][0];
for(i=0; i<=1; i++)
{
for(j=0; j<=3; j++)
{
printf("%d\n", *(*(ptr + i) + j) );
}
}
}
int main(void)
{
int i, j;
int array[2][4] = {{1,2,3,4}, {5,6,7,8}};
function(array, 4);
}
thanks
In C, many warnings are actually errors.Quote:
Originally Posted by taurus
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).
Yes!Quote:
Originally Posted by taurus
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:
array is not a ptp, it is a 2D array, and should NOT be passed as a ptp.Code:function(array, 4);
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:
You assign the value of the element 0, 0 to the pointer, which is 1. And 1 is not a valid address!Code:ptr = array[0][0];
Anything after this is guaranteed to go horrible and utterly wrong.
Secondly, this part:
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.Code:printf("%d\n", *(*(ptr + i) + j) );
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.
I did that but still doesnt seem to be happy with the passing of the 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("%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);
}
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:
Output: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("%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);
}
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
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.Quote:
Originally Posted by taurus
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.
Armed with this knowledge, perhaps it will become easier?Code:int x;
int* p = &x;
int** p2 = &p;
Ill have a read thanks, its a lot clearer now then at the start of the day
It basically never makes sense to take the address of an array; it wont help you. You MUST change the structure of the array you are passing if the function prototype is for a pointer-to-a-pointer-of-ints.Quote:
Originally Posted by taurus
It doesn't matter how many []'s are involved in declaring your array, it's still in one chunk of memory. e.g. These would be stored the same way in memory:And in fact you can initialise the first one like this too I believe, showing they're the same:Code:int a[2][2][2] = {{{1,2},{3,4}},{{5,6},{7,8}}};
int a[8] = {1,2,3,4,5,6,7,8};
To structure it as double-pointers, you need to have an array of pointers, that point to arrays of ints. Someone earlier posted an example that declared an array of pointers into the array of ints, and you could then pass that array of pointers. You just have to go back and find the correct post. Otherwise you have to create that array of pointers and then use malloc to create each sub-array.Code:int a[2][2][2] = {1,2,3,4,5,6,7,8};