Thread: function reveives a 2-d array as parameter

Code:

fun(int arr[][10]) ...

For a 3D array, you will need to specify:

Code:

fun3d(int arr[][10][10]);

Note that just becase a one-dimensional array will convert to a pointer, it doesn't automatically make a 2D array into a pointer to pointer - the compiler needs to know the dimensions aside from the first one [how LONG the 2D array is].

--
Mats

Yes, that's another variation. It basicly says "this is a pointer to an array of ten elements" [as opposed to the original form of "10 pointers to integers" - which isn't what you want].

--
Mats

thanks again,
i've another question now,
how to write a function that returns an address of a 2-d array?
mine: (revised twice - thanks to matsp)

Code:

#include <stdio.h>
void fun(int (*arr)[10]);
int send(void);

int main(void)
{
    int (*ptr)[10];
    ptr = send();
    fun(ptr);
return 0;
}
 void fun(int (*arr)[10])
 {
   int i;
   for(i=0; i<10; i++)
   {
     printf("&#37;d", arr[0][i]);
   }
  }
  
int send(void)        //here is the problem.....
{
    int static twodarray[10][10] = {0};
    return twodarray;  
}

(thank you Todd, but pleaseforgive me using my version ...for simplicity

Originally Posted by albert3721

thanks again,
i've another question now,
how to write a function that returns an address of a 2-d array?
mine:

Code:

#include <stdio.h>
void fun(int (*arr)[10]);
int send(void);

int main(void)
{
    int (*ptr)[10];
    ptr = send;
    fun(ptr);
return 0;
}
 void fun(int (*arr)[10])
 {
   int i;
   for(i=0; i<10; i++)
   {
     printf("%d", arr[0][i]);
   }
  }
  
int send(void)        //here is the problem.....
{
    int twodarray[10][10] = {0};
    return twodarray;  
}

(thank you Todd, but pleaseforgive me using my version ...for simplicity

1. You are not actually calling send, you are assigning a pointer with the address of the function send.
2. You are returning a local variable [twodarray in send], so that variable will "disappear" when the funciton returns.

--
Mats

Yes, yet again, we're attempting to convert ** into a 2D array. That's not what ** means. ** means that you have ONE variable that contains a pointer to a pointer to a integer.

A two dimensional array is a block of memory that is x elements wide and y elements "high".

You can use an array of y pointers that point to arrays of x elements, and a pointer to pointer that points to the y pointers. Something like this:

Code:

int ** fun1(void) {
	int **arr ;  
        arr = calloc(10, sizeof(int *));   // 10 pointers to integer. 
        for(i = 0; i < 10; i++) 
        {
	   arr[i] = calloc( 10 , sizeof(int) ) ; // 10 integers. 
        }
	return arr ; 
}

Just don't forget to do the opposite to free them later on.

--
Mats

You can return a pointer to a true 2D array inside a function, providing that the array is declared static (inside the function).

However, the syntax for the function declaration is a sight to behold!

Code:

#include <stdio.h>

int (*func(void))[10] {
    static int arr[10][10] = {
        { 1 },
        { 2 },
    };
    return arr;
}

int main ( ) {
    int r, c;
    int (*arr)[10] = func();
    for ( r = 0 ; r < 10 ; r++ ) {
        for ( c = 0 ; c < 10 ; c++ ) {
            printf( "&#37;d ", arr[r][c] );
        }
        printf( "\n" );
    }
    return 0;
}

Originally Posted by Salem

However, the syntax for the function declaration is a sight to behold!

"Beauty is in the eye of the beholder" as they say - in this case, I don't like it at all.

Also, a static return array is only good if you either:
- Only ever call it for ONE array at any given time - otherwise, the second array is an alias of the first one.
- Definitely DON'T use multithreading.

There are several ways to manage 2D arrays that is MUCH easier than returning an array from a function. For example, you can wrap the array into a struct, and use a pointer to the struct.

Or pass a 2D array in from the lower level call, rather than return it from a higher call.

--
Mats

I envisioned this as a block of 400 bytes (assuming an int is 4 bytes), but that is obviously not the case. The compiler is (essentially) hard coding the pointers for me, so there is really:

40 bytes for the 10 pointers ("i")
10 * 40 bytes for all the 2nd dimension pointers ("j")
400 bytes for the actual integers.

Yes, a simple 2D array is a block of 400 bytes. There are no "hidden pointers", etc when the compiler deals with it. The pointers become a must when you try to create your own 2D array, and use it as a pointer to pointer. [This makes it flexible as to what the two dimensions are too - you just change the internals of the function to make it 20 x 20].

You can ALSO create a block of 400 bytes, and return it using Salems "something to behold" syntax:

Code:

int (*func(void))[10] {
    int (*arr)[10];
    arr = calloc(10 * 10, sizeof(int));
    return arr;
}

This code only works for a [x][10] array - as it's a pointer to array of 10 integers.

--
Mats