Recientemente me topé con algún problema con las listas de inicializadores. Considere un programa que almacene datos similares a mapas

struct MyMapLike {
  MyMapLike(std::map<std::string, int> data)
    :data(std::move(data))
  { }

private:
  std::map<std::string, int> data;
};

Eso parece sencillo. Pero al inicializarlo, se vuelve feo. Quiero dejar que se vea como

MyMapLike maps = { { "One", 1 }, { "Two", 2 } };

Pero el compilador no quiere aceptar esto, porque lo anterior significa que debe buscar un constructor de dos parámetros que pueda aceptar{ "One", 1 } y{ "Two", 2 } respectivamente. Necesito agregar llaves adicionales, para que parezca un constructor de un solo parámetro que acepte la{ { ... }, { ... } }

MyMapLike maps = { { { "One", 1 }, { "Two", 2 } } };

No me gustaría escribirlo así. Como tengo una clase similar a un mapa y el inicializador tiene el valor abstracto de una lista de mapeo, me gustaría usar la versión anterior y ser independiente de cualquier detalle de implementación como el nivel de anidamiento de los constructores.

Una solución es declarar un constructor de lista de inicializadores

struct MyMapLike {
  MyMapLike(std::initializer_list< 
    std::map<std::string, int>::value_type
    > vals)
    :data(vals.begin(), vals.end())
  { }

  MyMapLike(std::map<std::string, int> data)
    :data(std::move(data))
  { }

private:
  std::map<std::string, int> data;
};

Ahora puedo usar el primero, porque cuando tengo un constructor de lista de inicializadores, toda la lista de inicializadores se trata como un elemento en lugar de dividirse en elementos. Pero creo que esta necesidad separada del constructor es fe

Estoy buscando orientación:

¿Qué piensa sobre la primera y la última forma de inicialización? ¿Tiene sentido que se requiera tener llaves adicionales en este caso? ¿Considera que el requisito para agregar un constructor de lista de inicializador en este caso es malo?

Si está de acuerdo conmigo en que la antigua forma de inicialización es mejor, ¿en qué soluciones puede pensar?