11

Consider the following code snippet, where the first line serves only as forward declaration

 class A;

followed by defining new class

class B
{
 vector<A> Av;  //line 1
 map<int, A> Am;  //line 2
 pair<int, A> Ap; //line 3
};

line 1 and line 2 seems to be fine with the forward declaration (which may tell me that those container use pointer type of implementation) where as line 3 does not seem to compile on VS2012.

My question is that behavior dictated by the standard or specific to the compiler I am using?

genpfault
  • 51,148
  • 11
  • 85
  • 139
user6386155
  • 825
  • 7
  • 17

3 Answers3

16

The relevant rules for the standard library types are in [res.on.functions]:

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, unless specifically allowed for that component.

This:

vector<A> Av;

is fine. std::vector is allowed to be instantiated with an incomplete type, as long as it becomes complete before you use any of the members. There is an explicit exception for this in the standard in [vector.overview]:

An incomplete type T may be used when instantiating vector if the allocator satisfies the allocator completeness requirements 17.6.3.5.1. T shall be complete before any member of the resulting specialization of vector is referenced.

There is similar wording for std::list and std::forward_list.

This:

map<int, A> Am;

is ill-formed. std::map requires a complete type at point of instantiation as per the first quote. There is no exception for this container in the way that there is for vector.

This:

pair<int, A> Ap;

cannot possibly ever work, since pair is just a simply struct with two members. In order to have a member of type A, you need a complete type.

Barry
  • 286,269
  • 29
  • 621
  • 977
  • If I'm not mistaken, the exceptions for vector, list and forward_list has been added for C++17 (I find it in n4606 but not in n3940; I'm not sure how much that was standardization of the current state of implementations, I seem to remember opposition by some but I don't follow the process as closely as before). – AProgrammer Aug 11 '16 at 14:38
  • 1
    @AProgrammer Yes, it's [N4510](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4510.html). Though libstdc++ and libc++ have allowed this for quite a while. – Barry Aug 11 '16 at 14:44
  • Thanks Barry. That helps a lot – user6386155 Aug 11 '16 at 14:49
6

[As supplemental instruction to Barry's answer]

According to the standard (C++17), only std::vector, std::list and std::forward_list could be used with incomplete type when instantiating.

§23.3.11.1/3 Class template vector overview [vector.overview]:

An incomplete type T may be used when instantiating vector if the allocator satisfies the allocator completeness requirements [allocator.requirements.completeness]. T shall be complete before any member of the resulting specialization of vector is referenced.

§23.3.9.1/4 Class template forward_list overview [forwardlist.overview]:

An incomplete type T may be used when instantiating forward_list if the allocator satisfies the allocator completeness requirements [allocator.requirements.completeness]. T shall be complete before any member of the resulting specialization of forward_list is referenced.

§23.3.10.1/3 Class template list overview [list.overview]:

An incomplete type T may be used when instantiating list if the allocator satisfies the allocator completeness requirements [allocator.requirements.completeness]. T shall be complete before any member of the resulting specialization of list is referenced.

songyuanyao
  • 169,198
  • 16
  • 310
  • 405
4

Nope, this behavior is expected and standard.

The rational is that std::pair actually forms a struct, therefore both its types must be complete before instantiation.

Kupto
  • 2,802
  • 2
  • 13
  • 16