Returning an array inside a structure that was allocated in afunction

[ctj951]

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 <iostream>
using namespace std;

struct Item
{
int itemNumber;
int internalItems[5];
};
Item CreateItem()
{
Item newItem;

newItem.itemNum ber = 10;

newItem.interna lItems[ 0 ] = 1;
newItem.interna lItems[ 1 ] = 2;
newItem.interna lItems[ 2 ] = 3;
newItem.interna lItems[ 3 ] = 7;
newItem.interna lItems[ 4 ] = 9;

return( newItem );
}
void PrintItem( Item iItemToPrint )
{
cout << iItemToPrint.in ternalItems[0];
}
int main ()
{
Item testItem = CreateItem();

PrintItem( testItem );

return 0;
}

This is a specific question about a specific language issue. Thank
You.

[Leandro Melo]

On 13 nov, 14:46, ctj951 <chadsspameater [e-mail] wrote:

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 <iostream>
using namespace std;

struct Item
* *{
* *int itemNumber;
* *int internalItems[5];
* *};

Item CreateItem()
* *{
* *Item newItem;

* *newItem.itemNu mber = 10;

* *newItem.intern alItems[ 0 ] = 1;
* *newItem.intern alItems[ 1 ] = 2;
* *newItem.intern alItems[ 2 ] = 3;
* *newItem.intern alItems[ 3 ] = 7;
* *newItem.intern alItems[ 4 ] = 9;

* *return( newItem );
* *}

void PrintItem( Item iItemToPrint )
* *{
* *cout << iItemToPrint.in ternalItems[0];
* *}

int main ()
* *{
* *Item testItem = CreateItem();

* *PrintItem( testItem );

* *return 0;
* *}

This is a specific question about a specific language issue. *Thank
You.

This is one of the reasons copy constructors exist. ;) Think about
which semantics you would like for a particular class (deep copy,
shallow copy) and write a copy constructor accordingly.

--
Leandro T. C. Melo

[Bo Persson]

ctj951 wrote:

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 <iostream>
using namespace std;

struct Item
{
int itemNumber;
int internalItems[5];
};
Item CreateItem()
{
Item newItem;

newItem.itemNum ber = 10;

newItem.interna lItems[ 0 ] = 1;
newItem.interna lItems[ 1 ] = 2;
newItem.interna lItems[ 2 ] = 3;
newItem.interna lItems[ 3 ] = 7;
newItem.interna lItems[ 4 ] = 9;

return( newItem );
}
void PrintItem( Item iItemToPrint )
{
cout << iItemToPrint.in ternalItems[0];
}
int main ()
{
Item testItem = CreateItem();

PrintItem( testItem );

return 0;
}

This is a specific question about a specific language issue. Thank
You.

This is quite ok. You are returning a struct, and all its members will
be copied. There are no pointers involved.
Bo Persson

[mail.dsp]

No need to think about it. Since in structure you've allocated memory
at compile time therefore default copy constructor will be invoked and
it will copy all the member of structure properly. Even it will work
in case of assignment too. But in case of run time allocation you'll
have to define your copy constructor(dee p copy) and overload
assignment operator for proper functionality.

--
Daya S. Prasad

[Leandro Melo]

On 13 nov, 15:02, Leandro Melo <ltcm...@gmail. comwrote:

On 13 nov, 14:46, ctj951 <chadsspameater [e-mail] wrote:

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 <iostream>
using namespace std;

struct Item
* *{
* *int itemNumber;
* *int internalItems[5];
* *};

Item CreateItem()
* *{
* *Item newItem;

* *newItem.itemNu mber = 10;

* *newItem.intern alItems[ 0 ] = 1;
* *newItem.intern alItems[ 1 ] = 2;
* *newItem.intern alItems[ 2 ] = 3;
* *newItem.intern alItems[ 3 ] = 7;
* *newItem.intern alItems[ 4 ] = 9;

* *return( newItem );
* *}

void PrintItem( Item iItemToPrint )
* *{
* *cout << iItemToPrint.in ternalItems[0];
* *}

int main ()
* *{
* *Item testItem = CreateItem();

* *PrintItem( testItem );

* *return 0;
* *}

This is a specific question about a specific language issue. *Thank
You.

This is one of the reasons copy constructors exist. ;) Think about
which semantics you would like for a particular class (deep copy,
shallow copy) and write a copy constructor accordingly.

Hmm... your array is statically allocated. No worry then.

--
Leandro T. C. Melo