在 2022/12/2 15:18, leon zadorin via Gcc-help 写道:
(1) On the one hand, given that I do instantiate ::std::optional with S (whith has member v whose elements' types, I guess(?) are at the line of declaring 'static ::std::optional<S> s', are still incompletely denifed, i.e. X) -- the clang discussion appears to say that at this moment optional is instantiated and S is incomplete (?) ... as so it is a UB... which I understood Jonathan's comment to relate to as well.
Yes this requires `S` to be complete.
(2) However, from your comment it would appear that 'instantiation of members of class template' is done afterwards anyways...
Only `S` itself is required to be complete.
In your code:
struct S {
::std::vector<::std::shared_ptr<J<X>>> v;
};
`S` _is_ complete. It does not matter whether it contains a `vector` of or a `shared_ptr` to
incomplete types, because the standard allows so. ([vector.overview] 4, [util.smartptr.shared] 2)
I suppose to reconcile both bits of info: (a) 'instantitation of members of class template' ... is it the same for instantitaion of the class template itself? (because UB specs appears to provide restrictions on std lib class instantiations, not specifically to inner members, but just for whole class)?; and
No.
```
struct T;
extern T* eptr; // okay; pointer to incomplete type
struct S
{
shared_ptr<T> mptr; // okay; `shared_ptr` to incomplete type
};
void
use_s()
{
S s; // oayk; `S` is complete
s.mptr.reset(); // okay; `reset()` does not require `T` to
// be complete
s.mptr.reset(::eptr); // error; instantiates the default
// deleter expression which requires
// `T` to be complete
}
```
(b) in the above code right at the line 'static ::std::optional<S> s' is S considered incomplete type at that moment?
No. See above.
... I'm just trying to figure out whether template "::std::optional<S>" is, itself, being instantiated at that very line (never mind its members) and if type S at that moment is considered to be incomplete... in which case it is UB... if not then may be its not a UB... I am confused :) ha ha :) wouldn't be the first time though :)
If `shared_ptr` is a bad example for you, here is a much simpler one:
```
struct incomplete;
struct complete
{
incomplete* ptr; // okay
incomplete& ref; // also okay
incomplete val; // invalid use of incomplete type
};
```
--
Best regards,
LIU Hao
Attachment:
OpenPGP_signature
Description: OpenPGP digital signature
