Returning structures

[kelvSYC]

What is the best way to create functions that, based on some input,
return either structures or a null value if the structure cannot be
made?

The problem is that the structure has be created inside the function,
and I've heard that returning a pointer to a locally created structure
is unsafe.

--
I am only a mirage.

[Victor Bazarov]

"kelvSYC" <ke*****@no.ema il.shaw.ca> wrote...

What is the best way to create functions that, based on some input,
return either structures or a null value if the structure cannot be
made?

The problem is that the structure has be created inside the function,
and I've heard that returning a pointer to a locally created structure
is unsafe.

Correct. But returning a pointer to a dynamically created structure
is perfectly fine. Just make sure that the caller disposes of it
correctly when they don't need it any longer.

SomeStruct* func() {
...
SomeStruct* toreturn = 0;
if (everything_is_ OK)
toreturn = new SomeStruct(argu ments);
...
return toreturn;
}

void foo() {
SomeStruct* pSS = func();
if (pSS) {
// do something
delete pSS;
}
}

Victor

[E. Robert Tisdale]

kelvSYC wrote:

What is the best way to create functions that, based on some input,
return either structures or a null value
if the structure cannot be made?

The problem is that the structure has be created inside the function,
and I've heard that returning a pointer to a locally created structure
is unsafe.

struct X { /* . . . */ };

X f(void) {
X x;
// modify x
return x;
}

This is the safest *and* most efficient way.
You can invoke it like this:

X x = f();

and *no* copies will be required if your C++ compiler implements
the Named Return Value Optimization (NRVO).

[Victor Bazarov]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > wrote...

kelvSYC wrote:

What is the best way to create functions that, based on some input,
return either structures or a null value
if the structure cannot be made?

The problem is that the structure has be created inside the function,
and I've heard that returning a pointer to a locally created structure
is unsafe.

struct X { /* . . . */ };

X f(void) {
X x;
// modify x
return x;
}

This is the safest *and* most efficient way.
You can invoke it like this:

X x = f();

and *no* copies will be required if your C++ compiler implements
the Named Return Value Optimization (NRVO).

What about the requirement to return something different (like 0)
to indicate the object creation is impossible?

Do you actually read the posts you reply to?

V

[E. Robert Tisdale]

Victor Bazarov wrote:

What about the requirement to return something different (like 0)
to indicate the object creation is impossible?

Do you actually read the posts you reply to?

Of course I do.
And I read your response which answered kelvSYC's question very well.

But I think that I gave the OP better advice.

[Chris Mantoulidis]

kelvSYC <ke*****@no.ema il.shaw.ca> wrote in message news:<050220041 256451981%ke*** **@no.email.sha w.ca>...

What is the best way to create functions that, based on some input,
return either structures or a null value if the structure cannot be
made?

The problem is that the structure has be created inside the function,
and I've heard that returning a pointer to a locally created structure
is unsafe.

Then don't return a pointer;

struct SimpleStruct {
bool valid;
string name;
//add more
}

SimpleStruct function_return s_ss(const string &name) {
SimpleStruct dummy;
if (name == "") dummy.valid = false;
else {
dummy.name = name;
dummy.valid = true;
}

return dummy;
}

int main() {
string name_given;

//prompt for name
cout << "Name: ";
cin >> name_given;

SimpleStruct rslt;
rslt = function_return _ss(name_given) ;
switch (rslt.valid) {
case false: cout << "no name...\n"; break;
case true: //..... do stuff.........
}

//.... do other stuff......

return 0;
}

This is the first solution that came to my mind. I know there's a
better one but it's too early for me to think of one ;)

[Siemel Naran]

"kelvSYC" <ke*****@no.ema il.shaw.ca> wrote in message
news:0502200412 56451981%

What is the best way to create functions that, based on some input,
return either structures or a null value if the structure cannot be
made?

The problem is that the structure has be created inside the function,
and I've heard that returning a pointer to a locally created structure
is unsafe.

Of course the easy solution is to document that your function may return a
new object, and that the caller ought to delete the object through delete,
free, or whatever is appropriate.

But you'll still get memory leaks as your program grows, because sooner or
later someone will screw up and forget to delete something.

So consider using a smart pointer like boost::shared_p tr or std::auto_ptr.
There's lots written about smart pointers. Search this newsgroup or the
internet, buy a book, etc.

And finally, you could return an object, and throw an exception to indicate
failure. Make sure to document the fact that your class may throw this or
that exception, but preferrably without exception specifications.

--
+++++++++++
Siemel Naran

[Siemel Naran]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > wrote in message

X f(void) {
X x;
// modify x
return x;
}

This is the safest *and* most efficient way.
You can invoke it like this:

X x = f();

and *no* copies will be required if your C++ compiler implements
the Named Return Value Optimization (NRVO).

Most compilers don't support this optimization at the present time. But one
could always move the body of f() and its function arguments, if any, into
the constructor X::X().

--
+++++++++++
Siemel Naran

[Eric Entressangle]

kelvSYC <ke*****@no.ema il.shaw.ca> wrote in message news:<050220041 256451981%ke*** **@no.email.sha w.ca>...

What is the best way to create functions that, based on some input,
return either structures or a null value if the structure cannot be
made?

The problem is that the structure has be created inside the function,
and I've heard that returning a pointer to a locally created structure
is unsafe.

Well, you could for example create your structure outside the
function, and pass it as out parameter to the function with your
inputs.

boolean function (struct & struct, input1, input2, ...)
{
//There, fill in struct with inputs
....
}

If the structure cannot be made, simply return true (or false, as
preferred).

[anubis]

Eric Entressangle wrote:

Well, you could for example create your structure outside the
function, and pass it as out parameter to the function with your
inputs.

boolean function (struct & struct, input1, input2, ...)
{
//There, fill in struct with inputs
...
}

If the structure cannot be made, simply return true (or false, as
preferred).

Actually, this solution is the best for me for these reasons :

- Having news and deletes in different scopes is very hard to maintain.
- Having a dynamic creation as it may not be required is bad ©.

With this solution, you could make a new or a static creation (as you
wish) and let the function "build" your structure. Then you could delete
it when job is done.

OT: And boolean does not exist in C++, only bool :-).

--
Anubis