Does std::map::iterator instantiate std::map?

Question

I have this code, which works on GCC:

#include <map>

class Foo;
class Bar;

typedef std::map<Foo,Bar> MyMap;

MyMap::iterator i;

class Foo
{
    MyMap::iterator some_data;
};

The code as currently designed (which is unpleasantly circular yes I'm stuck with it) requires map<Foo,Bar>::iterator to be available to Foo and Bar.

It works because the GCC library implementation happens to not need to instantiate the map's key type in order to instantiate the iterator.

Is this guaranteed? The standard seems to be somewhat hands-off when it comes to defining the map iterator type. How portable is this code?

You may need the exact version of the standard you care about; earlier standards where pretty broad with requirements that every type passed be complete. Later standards made it narrower. I don't know if that reduction in requirements change included std map. — Yakk - Adam Nevraumont, Mar 08 '19 at 14:21
`MyMap::iterator` requires `MyMap` (so `std::map`) (to answer to title). Not sure about completeness requirement key/value of `std::map`. — Jarod42, Mar 08 '19 at 14:26
`std::map` requires *complete types*. I would say that `::iterator` *should* too. — BiagioF, Mar 08 '19 at 14:32
Related to [forward-declaration-of-objects-with-stl-containers](https://stackoverflow.com/questions/38898935/forward-declaration-of-objects-with-stl-containers) — Jarod42, Mar 08 '19 at 14:41
@Jarod42 I'd say that answer answers this one. If you cannot `std::map` without a complete `Foo`, you cannot name `std::map::iterator` — Yakk - Adam Nevraumont, Mar 08 '19 at 14:47
@Yakk-AdamNevraumont Do you mean [this](https://stackoverflow.com/a/38899440/458742) means my code is not standards-compliant? — spraff, Mar 08 '19 at 15:09
@MaximEgorushkin No *value* is instantiated, but the *type* is. — Yakk - Adam Nevraumont, Mar 08 '19 at 15:55
@Yakk-AdamNevraumont We are talking about template instantiation here, and there is no template instantiated. — Maxim Egorushkin, Mar 08 '19 at 16:07
@MaximEgorushkin You are right; 14.7.1 Implicit instantiation [temp.inst] both says I am wrong (that `map` is an instantiation), and is far from easy to determine if `map ::interator` actually requires instantiating `map `. A Note: seems to imply it, but notes are non-normative. — Yakk - Adam Nevraumont, Mar 08 '19 at 16:27
I can't speak towards how legal this is, but if it turns out not be, I think it may be possible to achieve the same thing using the CRTP: `template struct WithMapData { std::map::iterator some_data; }; class Foo : WithMapData { /* inherit some_data */ };` — alter_igel, Mar 08 '19 at 18:40
@alterigel I have no idea why you think that would change anything? — Yakk - Adam Nevraumont, Mar 08 '19 at 18:42
@Yakk-AdamNevraumont I'm by no means an expert on the details of template instantiation, nor do I really understand why the CRTP works. I just thought it might offer a way to delay the need to use the iterator type until the `Foo` class is defined. I apologize if I'm just adding noise to the conversation — alter_igel, Mar 08 '19 at 18:44

score 3 · Accepted Answer · answered Mar 09 '19 at 06:39

This results in undefined behavior.

In the declaration MyMap::iterator i;, MyMap is required to be a complete type, thus it is implicitly instantiated. However, Foo and Bar are not complete at this point of instantiation, so the behavior is undefined according to [res.on.functions]/2:

In particular, the effects are undefined in the following cases:

...

if an incomplete type ([basic.types]) is used as a template argument when instantiating a template component or evaluating a concept, unless specifically allowed for that component.

Maxim Egorushkin · Answer 2 · 2019-03-08T17:50:01.290

0

You can side-step the entire question by considering the fact that std::map is a node-based container, so that its nodes containing elements have stable addresses. I.e. you can use a plain pointer instead of an iterator (as long as you don't need an iterator to pass into member functions of the std::map, of course):

class Foo
{
    std::pair<Foo const, Bar>* some_data;
};

Note that only declarations for Foo, Bar and std::pair<> are needed here to define member some_data.

If you use boost::multi_index (which is superior to std associative containers in many ways) then it has extremely useful functions to_iterator that takes a reference to the element and returns an iterator to it.

edited Mar 08 '19 at 17:50

answered Mar 08 '19 at 14:30

Maxim Egorushkin

131,725
17
180
271

doesnt this just move the question to whether `std::pair` can be instantiated with an incomplete type? – 463035818_is_not_an_ai Mar 08 '19 at 15:18
2

@user463035818 `std::pair<>` is not instantiated in `std::pair<>*`. Just like you can declare and pass around `std::ostream&` by only including its forward declaration `#include `. – Maxim Egorushkin Mar 08 '19 at 15:21

Does std::map::iterator instantiate std::map?

2 Answers2