Re: Class with functions that return STL containers with incomplete
types
On Jan 9, 9:38 pm, Joe Greer <jgr...@doubletake.com> wrote:
massysett <OriginalOm...@gmail.com> wrote
innews:315ae592-2b90-4285-b1b3-b4ffb6671ec1@h11g2000prf.googlegroups.com:
Having classes with member objects that have STL containers of objects
whose definitions are incomplete results in undefined behavior. See
for example:
http://www.ddj.com/database/184403814#8
http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.1=
4
I am wondering: is it okay to have member functions that return an STL
container with an incomplete type? My member objects do not contain
incomplete types. For instance, would the following code be OK?
#include <boost/shared_ptr.hpp>
#include <vector>
class HasSelf
{
public:
HasSelf(std::vector<HasSelf>& contents);
std::vector<HasSelf> getContents() const;
private:
std::vector<boost::shared_ptr<HasSelf> > _contents;
};
shared_ptr<> does not require that the class be complete, but
in this case, shared_ptr itself is complete. Therefore you
can have a vector of shared_ptrs to an incomplete class. I
assume that since the member is a vector of shared_ptrs, that
the other vectors are also vectors of shared_ptrs?
If I understand correctly, the vector isn't his problem. He
knows that that's OK. The problem is the parameter of the
constructor and the return value of getContents.
If I interpret the situation correctly: according to the
standard, it is undefined behavior to instantiate vector with an
incomplete type (and HasSelf only becomes complete at the
closing brace). However (=A714.7.1/1), "[...], the class template
is implicitly instantiated when the specialization is referenced
in a context that requires a completely-defined object type or
when the completeness of the class type affects the semantics of
the program." Since a reference or a return value may be an
incomplete type; the compiler should not instantiate the
template in this case, so the code is correct. (On the other
hand, converting between vector< HasSelf > and vector<
shared_ptr< HasSelf > > is typically not a trivial operation.
Quite frankly, I think I'd just use a std::vector< HasSelf >* as
the member.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34