The following code:
std::pmr::vector<std::pmr::vector<int>> outer_vec(std::pmr::get_default_resource());
outer_vec.emplace_back(std::pmr::get_default_resource());
fails with quite inconceivable error message ending with
static assertion failed: construction with an allocator must be possible if uses_allocator is true
The vector can clearly be constructed with an argument of std::pmr::get_default_resource(), such as:
std::pmr::vector<std::pmr::vector<int>> outer_vec(std::pmr::get_default_resource());
std::pmr::vector<int> inner_vec(std::pmr::get_default_resource());
outer_vec.push_back(std::move(inner_vec));
And std::pmr::vector can use emplace_back to construct an element, such as:
std::pmr::vector<std::vector<int>> outer_vec(std::pmr::get_default_resource());
outer_vec.emplace_back();
Why does the combination of both fails? What static_assert is failing?
Note that if the outer vector is not pmr, it works:
std::vector<std::pmr::vector<int>> vec;
vec.emplace_back(std::pmr::get_default_resource());
std::pmr::polymorphic_allocator uses uses-allocator construction if supported by the constructed type. std::vector does support uses-allocator construction and the allocator type of the inner std::vector is compatible with that of the outer one.
In consequence uses-allocator construction will be used by the outer vector. This means, whenever the vector constructs a new element it will automatically pass its own allocator as another argument to the constructor of the element. (Specifically get_allocator()->resource() is passed at the end of the argument list in this case.)
You are trying to pass an allocator manually to emplace_back, so that in effect with the above two allocators will be passed to the inner vector's construction, resulting in failure.
So, what you really want is just outer_vec.emplace_back();. It will propagate the outer vector's allocator to the inner vector.
Note that outer_vec.push_back(std::move(inner_vec)); will do the same. It will also propagate the outer allocator to the new "move"-constructed inner vector, resulting in moving all elements to a new allocation if necessary. It won't use the original allocation of inner_vec if its allocator compares unequal to outer_vec's allocator.