ctj951 <ch*****************@yahoo.comwrites:
I have a very specific question about a language issue that I was
hoping to get an answer to. If you allocate a structure that
contains
an array as a local variable inside a function and return that
structure, is this valid?
As shown in the code below I am allocating the structure in the
function and then returning the structure. I know if the structure
contained only simple types (int, float) this will work without
problems as you are getting a copy of those items returned from the
function. But I'm wondering with an array which is being returned
from the function as part of the structure is a pointer to the local
variable or perhaps a copy of that array (as it would be for simple
types). I think we might be getting a pointer returned but I'm not
sure.
#include <stdio.h>
struct Item
{
int itemNumber;
int internalItems[5];
};
struct Item CreateItem()
{
struct Item newItem;
newItem.itemNumber = 10;
newItem.internalItems[ 0 ] = 1;
newItem.internalItems[ 1 ] = 2;
newItem.internalItems[ 2 ] = 3;
newItem.internalItems[ 3 ] = 7;
newItem.internalItems[ 4 ] = 9;
return( newItem );
}
void PrintItem( struct Item iItemToPrint )
{
printf( "%d", iItemToPrint.internalItems[0] );
}
int main ()
{
struct Item testItem = CreateItem();
PrintItem( testItem );
return 0;
}
This comes close to a topic that we had a lengthy discussion about
just recently.
There's no problem with the code you posted.
<DIGRESSION>
Well, there are a couple of minor things, but they're not relevant to
your question. The way to declare function with no parameters is
"(void)"; "()" indicates an unspecified number and type of parameters,
which is legal but IMHO not as good. <OT>In C++, empty parentheses do
indicate that the function has no parameters.</OTThe parentheses on
the return statement are unnecessary (but harmless). And you should
print a new-line at the end of your output.
</DIGRESSION>
But there's an issue that you could run into.
As others have pointed out, a function returning a structure returns
it by value; the result is a single value of type struct ITem,
consisting of the values of the itemNumber and internalItems members.
There's no problem returning such a value from a function, assigning
it to an object or using to initialize an object, or passing it to
another function.
But if you tried to index the array member of the result directly, you
could run into problems.
For example, if you write:
printf("%d\n", CreateItem().internalItems[0]);
then something odd happens. CreateItem().internalItems is an
expression of array type. In most contexts, including this one, such
an expression is implicitly converted to a pointer to the first
element of the array object. The [0] indexing operator then extracts
the 0th element of that array object.
"What array object?", I hear you cry. Good question. The array is a
member of a struct *value*; there is no array object. But the C
standard says that there has to be an object. This is a hole in the C
standard, something that I suspect the authors just didn't think of at
the time. Different compilers may handle this differently; some
probably do handle it in such a way that it Just Works, but others
might not.
The workaround is simple: Don't directly index an array member of a
function result. Instead, save the returns struct value in an object
and use that to do the indexing, and you won't have to worry about
this issue.
The preliminary first draft of the C201X standard adds wording that
says an object of "temporary lifetime" is created in this case. Grab
a copy of n1336.pdf and see section 6.2.4 if you're really interested.
Incidentally, the form of your code makes me suspect that you're
actually working in C++. The difference doesn't affect the code you
posted (except perhaps for the meaning of the "()" in the function
declarations), but I think C++ handles the indexing glitch differently
(as I recall, a value returned from a function is treated as a
temporary object). If you care, ask in comp.lang.c++.
--
Keith Thompson (The_Other_Keith)
ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"