Initializing container of unique_ptr's using initialization list, continued - c++

Question

I would want to initialize std::vector's and std::map's of std::unique_ptr<T>'s. In my case, T is fixed. In this example I assume that T=int, although in reality it is a base class from which a bunch of other classes are derived.
I have been studying the answer given in:
https://stackoverflow.com/a/46771893/4875652
and I have not managed to get it working for the std::map case.
The following works:
#include <memory>
#include <vector>
struct movable_il {
mutable iptr t;
operator iptr() const&& { return std::move(t); }
movable_il( iptr&& in ): t(std::move(in)) {}
};
std::vector<iptr> vector_from_il( std::initializer_list<movable_il> il ) {
return std::vector<iptr>( std::make_move_iterator(il.begin()), std::make_move_iterator(il.end()) );
}
int main()
{
auto lol = vector_from_il({iptr{new int{3}}});
return 0;
}
However, the following does not:
#include <memory>
#include <map>
#include <utility>
using iptr = std::unique_ptr<int>;
struct movable_il {
mutable std::pair<std::string, iptr> t;
operator std::pair<std::string, iptr>() const&& { return std::move(t); }
movable_il( std::pair<std::string, iptr>&& in ): t(std::move(in)) {}
};
std::map<std::string, iptr> container_from_il( std::initializer_list< movable_il> il ) {
return std::map<std::string, iptr>( std::make_move_iterator(il.begin()), std::make_move_iterator(il.end()) );
}
int main()
{
auto lol = container_from_il({std::pair<std::string, iptr>{"a", iptr{new int{3}}}});
return 0;
}
Any ideas?
UPDATE:
The simplest working example I managed to get, that was as similar as possible to the original code, not using templates, is this:
#include <iostream>
#include <map>
#include <memory>
#include <utility>
struct movable_pair {
using first_type = std::string;
using second_type = std::unique_ptr<int>;
using pair_type = std::pair<const first_type, second_type>;
first_type first;
mutable second_type second;
operator pair_type() const && { return {first, std::move(second)}; }
movable_pair(pair_type &&in): first{in.first}, second{std::move(in.second)} {}
};
auto map_from_il(std::initializer_list<movable_pair> il) {
return std::map<std::string, std::unique_ptr<int>>(std::make_move_iterator(il.begin()),
std::make_move_iterator(il.end()));
}
// Main function
int main() {
using iptr = std::unique_ptr<int>;
auto lol = map_from_il({{{"a", iptr{new int{3}}}}, {{"b", iptr{new int{2}}}}});
// Small print-out to check we inserted the correct elements :)
for (auto &l : lol) {
std::cout << l.first << " " << *l.second << std::endl;
}
return 0;
}
Kudos to user Banan for the help, particularly figuring out the extra pair of curly braces needed.

Answer 1

The main problem, as far as I see it, is that you need to make the pair's movable. This is perfectly done by the movable_il class, but now you get into trouble trying to construct the map from these, as the first and second members are not defined for movable_il.
As you are anyways trying to construct the map from an iterator, I don't imagine you'll see any performance hit by doing the iteration yourself and inserting the elements manually. I've made a solution based on this. It's not the prettiest solution, but It'll do the job.
Furthermore I had some issues to get the compiler to deduce the correct type for T from the pair "initialization list", thus I made a small helper function movable_pair to create these, in which case the compiler has no problems.
#include <memory>
#include <map>
#include <utility>
#include <iostream>
#include <vector>
// Wrapper class to make type T "movable"
template<class T>
struct movable_il
{
mutable T t;
operator T() const&& { return std::move(t); }
movable_il( T&& in ): t(std::move(in)) {}
T get() const { return std::move(t); }
};
// Some template magic to deduce the correct value_type
// ( not really needed for this example as we are mostly interested in maps )
template<class VT>
struct fix_vt
{
using type = VT;
};
template<class VT>
using fix_vt_t = typename fix_vt<VT>::type;
template<class VT> struct fix_vt<const VT> : fix_vt<VT> {};
template<class K, class V>
struct fix_vt< std::pair<K,V> >
{
using type = std::pair<
typename std::remove_cv<K>::type,
typename std::remove_cv<V>::type
>;
};
// Create map from initializer list of movable T (pairs)
template<class C, class T = fix_vt_t<typename C::value_type> >
auto map_from_il(std::initializer_list< movable_il<T> > il)
{
using map_type = C;
auto map = map_type{};
// Loop over il list and insert each element into the map
for(auto&& entry : il)
{
map.insert(std::move(entry.get())); // We get the pair from the movable class and insert it by moving
}
return map;
}
// Helper function to create movable pair
template<class First, class Second>
auto movable_pair(First&& f, Second&& s)
{
using pair_type = std::pair<First, Second>;
return movable_il<pair_type>{ pair_type{ std::forward<First>(f), std::forward<Second>(s) } };
}
// Main function
int main()
{
using iptr = std::unique_ptr<int>;
using key_type = std::string;
using value_type = iptr;
using map_type = std::map<key_type, value_type>;
auto lol = map_from_il<map_type>({ movable_pair("a", iptr{ new int {3} } ), movable_pair("b", iptr{ new int {2} }) });
// Small print-out to check we inserted the correct elements :)
for(auto& l : lol)
{
std::cout << l.first << " " << *l.second << std::endl;
}
return 0;
}
Disclaimer: I have only tested this with GCC 8.1.0 (but I don't imagine any issues using other compilers).
Update: If you put in and extra set of { and } when passing the pairs to map_from_il, the code compiles without the use of the movable_pair helper function.
auto lol = map_from_il<map_type>({ { {"a", iptr{ new int {3} } } }, { {"b", iptr{ new int {2} } } } });
Update 2: If you add the following constructor to movable_il, the code also compiles without the extra { and }:
template<class... U>
movable_il( U&&... in): t{std::forward<U>(in)...} {}
With this you can write:
auto lol = map_from_il<map_type>({ {"a", iptr{ new int {3} } }, {"b", iptr{ new int {2} } } });