Printable View
Hi guys,
How can I pass a 2 dimensional array to a function using [] and pointer *?
Many thanksCode:void InputString(????) // Emp[][] , **Emp ??
{
}
int main(void)
{
char cEmployee[5][20];
int i;
for (i=0;i<5;++i)
{
puts("Enter name:");
InputString(??????);
}
return 0;
}
If i remember correctly, this should do it:
Basically you just pass the pointer to the first element in the array.Code:void foo(char* array)
{
}
int main()
{
char array[10][10];
foo(array);
}
I dont think that will work. That only works on one dimensional arrays. It cannot work on 2 dimensional arrays because it would need to know the size of at least one of the dimensions in order for it to be able to calculate the position of the element.
Havnt tried but maybe this:
If you've ever tried to simulate a 2 dimensional array using just one dimension it might of looked like this:Code:void InputString(char array[5][])
{
}
It need to know to know the "width" of the array in order for it to calculate its single dimension position.Code:const int width = 5;
const int height = 10;
int myArray[width * height];
...
...
int someElement = myArray[4 * width + 3]; //like myArray[3, 4];
The easiest way is to just make the function parameter look like the same type you're passing to it, then just pass the array:
As has been hinted, there are multiple ways of writing InputString that are the same:Code:void InputString(char employee[5][20]) {}
/* ... */
char cEmployee[5][20];
InputString(cEmployee);
Why these are all equivalent is probably a matter best left for later in your C education. For now, just pick one: the one listed second seems to be most common, in my experience.Code:void InputString(char employee[5][20]);
void InputString(char employee[][20]);
void InputString(char (*employee)[20]);
They are not the same.
http://c-faq.com/aryptr/index.html
You don't need to pass the function the size of the array's first dimension, but you may (the compiler will ignore it). The last dimension size, you must pass though.
If this is in reply to my post, please explain how those function prototypes differ; I'm quite sure they don't.Quote:
Originally Posted by robwhit
If it's not, then ignore this. ;)
You can use pointer arithmetic with the pointer version, not with the others.
The 2nd one has an unspecified number of elements, the first one has a specifed number of elements. That means that if you enter in an invalid index constant in the first one, you'll probably get a compile error.
And whatever other differences are in the link.
They're all the same; note that these are prototypes, and as a parameter of a prototype, what looks like an array is really a pointer (this is not the case elsewhere, of course).Quote:
Originally Posted by robwhit
You can indeed do pointer arithmetic with the parameter of all three methods because they are identical. You can do pointer arithmetic on arrays, too (because arrays decay into pointers in most cases), but I presume you mean something like employee++? That's still possible with all the prototypes I showed due, again, to the fact that arrays aren't really arrays (in this particular context).
Here's a demonstration:
I used a single array for simplicity; this naturally holds for multidimensional arrays, but it gets slightly more complicated because you start to deal with pointers to arrays.Code:#include <stdio.h>
static void f1(int *p)
{
printf("%d\n", *++p);
}
static void f2(int p[])
{
printf("%d\n", *++p);
}
int main(void)
{
int a[] = { 1, 2 };
f1(a);
f2(a);
return 0;
}
You can, perhaps, further convince yourself with this:
Unless you're on an absolutely bizarre system, two different numbers should come out: 11 in main() (this won't change regardless of platform), and probably 4 in f() (depending on the size of a pointer).Code:#include <stdio.h>
static void f(char p[11])
{
printf("In f(): %lu\n", (unsigned long)sizeof p);
}
int main(void)
{
char a[11];
printf("In main(): %lu\n", (unsigned long)sizeof a);
f(a);
return 0;
}
Despite the fact that it looks like an array, inside the function f(), p is a pointer.
This is covered in section 6.4 of the FAQ link you posted.
Dang, you're right. It even keeps the value assigned and does no type check whatsoever on the size.
Even this prints 4:I thought that they worked like arrays and that the FAQ was just keeping things simple or something.Code:#include <stdio.h>
typedef int arr[5];
static void f1(arr p)
{
typeof (p) arr2;
printf("%lu\n", (long unsigned) sizeof arr2);
}
int main(void)
{
int a[3] = { 1, 2 };
f1(a);
return 0;
}
I really should use my compiler more...
Thanks for pointing this out. :)