STL-container used with references

[Severin Ecker]

hi!

normally i would simply do the following:

std::vector<Ele ment> vec;
void somefunc() {
Element e;
vec.push_back(e );
}

now Element e is in the vector. thats fine as long as no polymorphic
behaviour is needed.

std::vector<Ele ment &> vec;
void somefunc() {
Derived_from_El ement e;
vec.push_back(e ); //bad idea,.. e is gone after functionscope is left
}

what i want to avoid (if possible) are 2 things:
dynamic allocation of the objects, and having an extracontiner for every
type derived from the basetype to store the elements.

i hope, i made clear what i'm trying to do... so is there a solution (except
for the 2 mentioned above?)

thx, regards,
sev

[tom_usenet]

On Tue, 6 Apr 2004 15:04:53 +0200, "Severin Ecker" <se****@gmx.a t>
wrote:

hi!

normally i would simply do the following:

std::vector<El ement> vec;
void somefunc() {
Element e;
vec.push_back(e );
}

now Element e is in the vector. thats fine as long as no polymorphic
behaviour is needed.

std::vector<El ement &> vec;
You can't hold references in containers - references are just aliases,
not real objects.
void somefunc() {
Derived_from_El ement e;
vec.push_back(e ); //bad idea,.. e is gone after functionscope is left
}

what i want to avoid (if possible) are 2 things:
dynamic allocation of the objects, and having an extracontiner for every
type derived from the basetype to store the elements.

i hope, i made clear what i'm trying to do... so is there a solution (except
for the 2 mentioned above?)

It is obviously hard to avoid dynamic allocation of the objects, since
all of your derived types can have different sizes and alignment
requirements. There are techniques for doing it (as long as all
derived classes are known in advance), but they would be premature
optimization in this case I am sure. Your best bet is to use a
container of smart pointers:

std::vector<sha red_ptr<Element > > vec;
vec.push_back(s hared_ptr<Eleme nt>(new Derived_from_El ement));

See www.boost.org for shared_ptr.

Tom
--
C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html

[tom_usenet]

On Tue, 6 Apr 2004 15:04:53 +0200, "Severin Ecker" <se****@gmx.a t>
wrote:

hi!

normally i would simply do the following:

std::vector<El ement> vec;
void somefunc() {
Element e;
vec.push_back(e );
}

now Element e is in the vector. thats fine as long as no polymorphic
behaviour is needed.

std::vector<El ement &> vec;
You can't hold references in containers - references are just aliases,
not real objects.
void somefunc() {
Derived_from_El ement e;
vec.push_back(e ); //bad idea,.. e is gone after functionscope is left
}

what i want to avoid (if possible) are 2 things:
dynamic allocation of the objects, and having an extracontiner for every
type derived from the basetype to store the elements.

i hope, i made clear what i'm trying to do... so is there a solution (except
for the 2 mentioned above?)

It is obviously hard to avoid dynamic allocation of the objects, since
all of your derived types can have different sizes and alignment
requirements. There are techniques for doing it (as long as all
derived classes are known in advance), but they would be premature
optimization in this case I am sure. Your best bet is to use a
container of smart pointers:

std::vector<sha red_ptr<Element > > vec;
vec.push_back(s hared_ptr<Eleme nt>(new Derived_from_El ement));

See www.boost.org for shared_ptr.

Tom
--
C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html

[Howard]

"tom_usenet " <to********@hot mail.com> wrote in message

...Your best bet is to use a
container of smart pointers:

std::vector<sha red_ptr<Element > > vec;
vec.push_back(s hared_ptr<Eleme nt>(new Derived_from_El ement));

See www.boost.org for shared_ptr.

Just curious...What if you don't have (or want) boost? Is there an STL
solution similar to shared_ptr?

-Howard

[Howard]

"tom_usenet " <to********@hot mail.com> wrote in message

...Your best bet is to use a
container of smart pointers:

std::vector<sha red_ptr<Element > > vec;
vec.push_back(s hared_ptr<Eleme nt>(new Derived_from_El ement));

See www.boost.org for shared_ptr.

Just curious...What if you don't have (or want) boost? Is there an STL
solution similar to shared_ptr?

-Howard

[John Harrison]

"Howard" <al*****@hotmai l.com> wrote in message
news:c4******** @dispatch.conce ntric.net...

"tom_usenet " <to********@hot mail.com> wrote in message

...Your best bet is to use a
container of smart pointers:

std::vector<sha red_ptr<Element > > vec;
vec.push_back(s hared_ptr<Eleme nt>(new Derived_from_El ement));

See www.boost.org for shared_ptr.

Just curious...What if you don't have (or want) boost? Is there an STL
solution similar to shared_ptr?

No, but it's really very simple to roll your own basic smart pointer. It
would not have all the functionality of boost's but would certainly support
polymorphism and automatic cleanup.

Have a look at Scott Meyers book for example code (I think its the More
Effective C++ one).

john

[John Harrison]

"Howard" <al*****@hotmai l.com> wrote in message
news:c4******** @dispatch.conce ntric.net...

"tom_usenet " <to********@hot mail.com> wrote in message

...Your best bet is to use a
container of smart pointers:

std::vector<sha red_ptr<Element > > vec;
vec.push_back(s hared_ptr<Eleme nt>(new Derived_from_El ement));

See www.boost.org for shared_ptr.

Just curious...What if you don't have (or want) boost? Is there an STL
solution similar to shared_ptr?

No, but it's really very simple to roll your own basic smart pointer. It
would not have all the functionality of boost's but would certainly support
polymorphism and automatic cleanup.

Have a look at Scott Meyers book for example code (I think its the More
Effective C++ one).

john

[tom_usenet]

On 06 Apr 2004 11:14:31 EDT, "Howard" <al*****@hotmai l.com> wrote:

"tom_usenet " <to********@hot mail.com> wrote in message

...Your best bet is to use a
container of smart pointers:

std::vector<sha red_ptr<Element > > vec;
vec.push_back(s hared_ptr<Eleme nt>(new Derived_from_El ement));

See www.boost.org for shared_ptr.

Just curious...What if you don't have (or want) boost? Is there an STL
solution similar to shared_ptr?

boost::shared_p tr has been proposed for standardization as part of the
library technical report. Look out for std::tr1::share d_ptr, coming to
your compiler soon.

There is no current standard solution, except to write your own smart
pointer class (not at all recommended - matching boost::shared_p tr's
functionality is non-trivial).

Tom
--
C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html

[tom_usenet]

On 06 Apr 2004 11:14:31 EDT, "Howard" <al*****@hotmai l.com> wrote:

"tom_usenet " <to********@hot mail.com> wrote in message

...Your best bet is to use a
container of smart pointers:

std::vector<sha red_ptr<Element > > vec;
vec.push_back(s hared_ptr<Eleme nt>(new Derived_from_El ement));

See www.boost.org for shared_ptr.

Just curious...What if you don't have (or want) boost? Is there an STL
solution similar to shared_ptr?

boost::shared_p tr has been proposed for standardization as part of the
library technical report. Look out for std::tr1::share d_ptr, coming to
your compiler soon.

There is no current standard solution, except to write your own smart
pointer class (not at all recommended - matching boost::shared_p tr's
functionality is non-trivial).

Tom
--
C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html

[Mike Wahler]

"tom_usenet " <to********@hot mail.com> wrote in message
news:ne******** *************** *********@4ax.c om...

Just curious...What if you don't have (or want) boost? Is there an STL
solution similar to shared_ptr?

boost::shared_p tr has been proposed for standardization as part of the
library technical report. Look out for std::tr1::share d_ptr, coming to
your compiler soon.

Curiosity:

What's the significance of the (namespace?) name 'tr1'?

-Mike