Question about this piece of code.

[Jianwei Sun]

I am reading a peice of code which is at the following link:
http://www.brpreiss.com/books/opus4/...00000000000000

The code is like this:

Object& StackAsLinkedList::Pop()
{
if(count==0)
throw domain_error("stack is empty");

Object& const result=*list.First();
list.Extract(&result);
--count;
return result;
}

Does this code return a reference to local variable result? If this is the
case, then this code
has problem?

Thanks,
J.W.

[Jianwei Sun]

I am reading a peice of code which is at the following link:
http://www.brpreiss.com/books/opus4/...CTION007123000
000000000000

The code is like this:

Object& StackAsLinkedList::Pop()
{
if(count==0)
throw domain_error("stack is empty");
Object& const result=*list.First();
list.Extract(&result);
--count;
return result;
}
Does this code return a reference to local variable result? If this is
the case, then this code has problem?

Thanks,
J.W.

The list extract function is here:

http://www.brpreiss.com/books/opus4/...00000000000000

[Salt_Peter]

On Aug 10, 11:12 am, Jianwei Sun <[e-mail]:

I am reading a peice of code which is at the following link:http://www.brpreiss.com/books/opus4/...ECTION00712300...

The code is like this:

Object& StackAsLinkedList::Pop()
{
if(count==0)
throw domain_error("stack is empty");

Object& const result=*list.First();
list.Extract(&result);
--count;
return result;

}

Does this code return a reference to local variable result? If this is the
case, then this code
has problem?

the function returns a reference (as required since the function's
return type is Object&).
The declaration for result is a const reference:
Object& const result(*list.First());
In effect, you aren't dealing with a temporary variable. Passing
references by value doesn't magicly allocate or deallocate its
referant.

Whether the code is correct is unknown to us. In particular, no-one
here knows what happens to result (the Object) during and after the
call to list.Extract(&result). We have no way of knowing how (or if)
the list is managing the Object lifetimes.

[Jianwei Sun]

Hello Salt_Peter,

On Aug 10, 11:12 am, Jianwei Sun <[e-mail]:

>I am reading a peice of code which is at the following
link:http://www.brpreiss.com/books/opus4/...tml#SECTION007
12300...

The code is like this:

Object& StackAsLinkedList::Pop()
{
if(count==0)
throw domain_error("stack is empty");
Object& const result=*list.First();
list.Extract(&result);
--count;
return result;
}

Does this code return a reference to local variable result? If this
is the
case, then this code
has problem?

the function returns a reference (as required since the function's
return type is Object&).
The declaration for result is a const reference:
Object& const result(*list.First());
In effect, you aren't dealing with a temporary variable. Passing
references by value doesn't magicly allocate or deallocate its
referant.
Whether the code is correct is unknown to us. In particular, no-one
here knows what happens to result (the Object) during and after the
call to list.Extract(&result). We have no way of knowing how (or if)
the list is managing the Object lifetimes.

Hi, Peter,

The extact function is here:

http://www.brpreiss.com/books/opus4/...00000000000000

If I get your meaning correclty, if the extract is deleting this node, then
this won't be correct.
If the extact doesn't delete this node, this will work fine.

Thanks,
J.W.

[AnonMail2005]

On Aug 10, 11:18*am, Jianwei Sun <[e-mail]:

I am reading a peice of code which is at the following link:
http://www.brpreiss.com/books/opus4/...CTION007123000
000000000000

The code is like this:

Object& StackAsLinkedList::Pop()
{
if(count==0)
throw domain_error("stack is empty");
Object& const result=*list.First();
list.Extract(&result);
--count;
return result;
}
Does this code return a reference to local variable result? If this is
the case, then this code has problem?

Thanks,
J.W.

The list extract function is here:

http://www.brpreiss.com/books/opus4/...210000...-Hide quoted text -

- Show quoted text -

If we ignore that result is a const and the return type is non-const,
it would seem that the returned value (a reference) refers to an
object that has been deleted inside the Extract function. This, of
course, is wrong.

[Jianwei Sun]

Hello An**********@gmail.com,

On Aug 10, 11:18 am, Jianwei Sun <[e-mail]:

>>I am reading a peice of code which is at the following link:
http://www.brpreiss.com/books/opus4/...SECTION0071230
00 000000000000

The code is like this:

Object& StackAsLinkedList::Pop()
{
if(count==0)
throw domain_error("stack is empty");
Object& const result=*list.First();
list.Extract(&result);
--count;
return result;
}
Does this code return a reference to local variable result? If this
is
the case, then this code has problem?
Thanks,
J.W.

The list extract function is here:

http://www.brpreiss.com/books/opus4/...CTION005210000
...- Hide quoted text -

- Show quoted text -

If we ignore that result is a const and the return type is non-const,
it would seem that the returned value (a reference) refers to an
object that has been deleted inside the Extract function. This, of
course, is wrong.

Thank you for verify, I just want to make sure I didn't miss something obvious
since the author who maintains
this tutorial is a very knowledgeable person and this book is a 5-star book
on amazon.com

Thanks,
J.W.

[Triple-DES]

On 10 Aug, 19:56, Jianwei Sun <[e-mail]:

Thank you for verify, I just want to make sure I didn't miss something obvious
since the author who maintains
this tutorial is a very knowledgeable person and this book is a 5-star book
on amazon.com

Thanks,
J.W

Still, I think the author's approach is inherently flawed. Why would
you want to implement your own data structures based on storing
pointers to an Object base class in C++? That's more like pre-generics
Java than idiomatic C++.

For C++, I recommend reading up on the STL instead.

DP