Re: Using incomplete types to instantiate STL-Templates?

Re: Using incomplete types to instantiate STL-Templates?

[Wolfgang Bangerth]

Note that libstdc++ _does_ actually accept the code Christian showed. It 
only rejects it if concepts checking is on. I think that's weird, and 
personally consider it a defect in the way the concepts checks are 
implemented. 

In this case, the concepts checks are placed at class declaration level,
which is too early. Since std::list only stores pointers to objects, the 
class pointed to needs not be complete at this time. It would be 
sufficient to place the concepts check into one of the member functions, 
by which the requirement of completeness of _Tp would be deferred.

However, that's just a layman's opinion :-)

W.

-------------------------------------------------------------------------
Wolfgang Bangerth              email:            bangerth@ices.utexas.edu
                               www: http://www.ices.utexas.edu/~bangerth/

Re: Using incomplete types to instantiate STL-Templates?

[Gabriel Dos Reis]

Wolfgang Bangerth <bangerth@ices.utexas.edu> writes:

| Note that libstdc++ _does_ actually accept the code Christian showed. It 
| only rejects it if concepts checking is on.

Yes, that is what I was referring to when I said that accepting the
code puts severe restrictings on the implementations.

I don't think there is much we can do about it -- we all know the code
is violating a specific clause, e.g. constructing a list of incomplete
type.  

| I think that's weird, and 
| personally consider it a defect in the way the concepts checks are 
| implemented. 

STL concepts  checking in pure C++ is a tough task.  I would be pleased to
read your implementations :-)

[ I do know for sure that como + libcomo and concept checking does
 reject some well-formed programs ]

-- Gaby

Re: Using incomplete types to instantiate STL-Templates?

[Wolfgang Bangerth]

> | I think that's weird, and 
> | personally consider it a defect in the way the concepts checks are 
> | implemented. 
> 
> STL concepts  checking in pure C++ is a tough task.  I would be pleased to
> read your implementations :-)

Fair enough. I didn't imply any blame in my wording -- heck, all my job in 
gcc is pointing out errors in some part of gcc or other ;-) If I had to 
fix them all, I'd have a problem...

What I thought is that deferring concepts check to the time we actually 
instantiate an object might be done by placing the check machinery into 
the constructors, since that's the first place we end up in anyway.

[Thinks] Actually, that's not true -- you might just be passed a pointer 
and call member functions from there. So one would have to duplicate 
concepts checks in _all_ member functions. Nope, I don't think we want to 
do that. 

I think I now see what you mean :-) That being said, I still think it's a 
defect, even though it may be impossible to fix it.

Time for constraints on template parameters...

W.

-------------------------------------------------------------------------
Wolfgang Bangerth              email:            bangerth@ices.utexas.edu
                               www: http://www.ices.utexas.edu/~bangerth/

Re: Using incomplete types to instantiate STL-Templates?

[Fergus Henderson]

On 30-Apr-2003, Wolfgang Bangerth <bangerth@ices.utexas.edu> wrote:
> 
> Note that libstdc++ _does_ actually accept the code Christian showed. It 
> only rejects it if concepts checking is on. I think that's weird, and 
> personally consider it a defect in the way the concepts checks are 
> implemented. 

The point of concept checking is to check that the class used to
instantiated a template meets (the checkable subset of) the standard's
requirements.  One of the requirements that the standard imposes is that
the class must be complete.  So it is surely right for the concept checking
to reject such classes!

-- 
Fergus Henderson <fjh@cs.mu.oz.au>  |  "I have always known that the pursuit
The University of Melbourne         |  of excellence is a lethal habit"
WWW: <http://www.cs.mu.oz.au/~fjh>  |     -- the last words of T. S. Garp.

Re: Using incomplete types to instantiate STL-Templates?

[Gabriel Dos Reis]

"Christian Ehrhardt" <ehrhardt@mathematik.uni-ulm.de> writes:


[...]

| * For the standard library there is this restriction in 17.3.4.6[2]:
| 
| 	In particular, the effects are undefined in the following cases:
| 	[ ... ]
| 	-- if an incomplete type (3.9) is used as a template argument
| 	   when instantiating a template component.
| 
| I'm not sure if the second point is really relevant. Mostly because
| I'm not entirely sure what a template component is supposed to be.

The text you cited is relevant:  The component in question in this
particular configuration is std::list<>.

This is the kind of thing that really depends on implementation details.
It would be nice if Foo were accepted but that do put severe
restrictions on the implementation.

-- Gaby

Using incomplete types to instantiate STL-Templates?

[Christian Ehrhardt]

Hi,

the following piece of code fails with --enable-concept-checks
(this is PR 10505):

------- cut ----------
#include <list>
class   Foo
{
public:
	int x;
	std::list<Foo>  children;
};
------- cut ----------

This happens because instantiation of std::list<Foo> will try to
declare a variable of type Foo. This fails because Foo is incomplete
at the point of instantiation. Basically the question is:
Is this construct legal?

I could only find two things that might be relevant to this in the
standard:
* Generally it is allowed to instatiate a template with an incomplete type.
  However, the program may be ill-formed depending on what the template does
  with this incomplete type (I can dig up the section numbers if this is
  necessary).
* For the standard library there is this restriction in 17.3.4.6[2]:

	In particular, the effects are undefined in the following cases:
	[ ... ]
	-- if an incomplete type (3.9) is used as a template argument
	   when instantiating a template component.

I'm not sure if the second point is really relevant. Mostly because
I'm not entirely sure what a template component is supposed to be.

   regards    Christian

--
THAT'S ALL FOLKS!