Hi all,
What should I write for function signature in order to return this 6X6 array without compiler error? I tried to use int* getGraph(), but it did not work.
Thanks for your help.

int[6][6] getGraph()
{
    int graph[6][6] = {
        {0,   5, 10, -1, -1, -1},
        {-1,  0, -1,  2, -1, -1},
        {-1, -1,  0, -1, 10, -1},
        {-1, -1, -1,  0,  1, -1},
        {-1, -1, -1, -1,  0, 10},
        {-1, -1, -1, -1, -1,  0} };

    return graph;
}

Edited 3 Years Ago by pyTony: fixed formating

I'm unsure of this but I don't think "int [6][6]" will work. Did you try "int getGraph()" and "return graph[6][6]"?

When you return from your proposed function, the local data goes out of scope. So it is not useful to do it this way. Could you describe what it is you would like to accomplish?

To Kalachylde: It does not perform what we are expected to because of two reasons: it will return integer instead of array of integer, and return graph[6][6] means creating one new array of integer with size 6X6 without initialization.

To Dave Sinkula: I think although the local data goes out of scope, we still get the correct result because the local data is copied to a temporary memory, which is returns to the caller before the local data going out of scope.

Now, I think the least sufficient way is using class (wrapper the multi-array), and returning its's object. However, if anyone has a greater idea, please share with us.

By the way, thanks for both your inputs.

Unless there is some language extension with which I am not yet familiar, you cannot return arrays (I'm more sure of this for C). An array name, when used in an expression, decays to a pointer to the first element. The function would then be returning a pointer to local data that is now out of scope. It may appear to be correct, or it may not -- both are within the realm of undefined behavior.

If the array is within a class (again I'm going with more familiarity with C's structs) -- yes, you can return an object.

Another idea: pass a pointer to the start and copy the desired contents there.

#include <stdio.h>
#include <string.h>
void getGraph(int my_graph[6][6])
{
   static const int default_graph[6][6] =
   {
	  { 0,  5, 10, -1, -1, -1},
	  {-1,  0, -1,  2, -1, -1},
	  {-1, -1,  0, -1, 10, -1},
	  {-1, -1, -1,  0,  1, -1},
	  {-1, -1, -1, -1,  0, 10},
	  {-1, -1, -1, -1, -1,  0},
   };
   memcpy(my_graph, default_graph, sizeof default_graph);
}
int main(void) 
{
   int graph[6][6];
   getGraph(graph);
   /* ... */
   return 0;
}

Yes. Absolutely, you are right about local data goes out of scope, but the value is always correct since the pointer is going out of scope, but the memory, which pointer pointed to is still there unless you explicitly delete pointer, then that memory location will contain garbage.
I really appreciate for your help.

Yes. Absolutely, you are right about local data goes out of scope, but the value is always correct since the pointer is going out of scope, but the memory, which pointer pointed to is still there unless you explicitly delete pointer, then that memory location will contain garbage.

No. Undefined behavior is, well, undefined behavior.

Let's say you have an array local to a function. This data is created on the stack. You call this function and return a pointer to the first element of it -- you are pointing somewhere on the stack.

Then you call another function that also has local variables. This function also uses the stack, and it tramples your data. And the pointer returned by the first function is still pointing to the same place.

This is just one possible example of your assertion being incorrect. So "always correct" is not true.

[edit]Since you can't return an array, this is the closest simulation I could devise.

#include <stdio.h>
int *getGraph(void)
{
   int init[6][6] =
   {
   { 0,  5, 10, -1, -1, -1},
   {-1,  0, -1,  2, -1, -1},
   {-1, -1,  0, -1, 10, -1},
   {-1, -1, -1,  0,  1, -1},
   {-1, -1, -1, -1,  0, 10},
   {-1, -1, -1, -1, -1,  0},
   };
   int i, j;
   puts("getGraph:");
   for (i = 0; i < 6; ++i)
   {
	  for (j = 0; j < 6; ++j)
	  {
		 printf("%2d ", init[i][j]);
	  }
	  putchar('\n');
   }
   return init;
}
void printGraph(const int g[6][6])
{
   int i, j;
   puts("printGraph:");
   for (i = 0; i < 6; ++i)
   {
	  for (j = 0; j < 6; ++j)
	  {
		 printf("%2d ", g[i][j]);
	  }
	  putchar('\n');
   }
}
int main(void) 
{
   int (*graph)[6] = getGraph();
   printGraph(graph);
   return 0;
}
/* my output
getGraph:
 0  5 10 -1 -1 -1 
-1  0 -1  2 -1 -1 
-1 -1  0 -1 10 -1 
-1 -1 -1  0  1 -1 
-1 -1 -1 -1  0 10 
-1 -1 -1 -1 -1  0 
printGraph:
 0  5 10 -1 -1 -1 
-1  0 -1  2 -1 4223327 
-1 1245004 10 1244919 4223327 4223339 
 0 11 -1 -1 1245028 4209022 
4208532 4224044 4223339 1245044 1245056 4198704 
4223339 4223339  0 4223088  0 1245068 
*/

Sorry! I take back my words. In the above case it is wrong since the above array is not allocated in the heap(unless using new operator), so you are 100% correct. (I messed up with Java since array is object).

This article has been dead for over six months. Start a new discussion instead.