Me gustaría inicializar una @ estátistd::map donde el valor no se puede copiar. Llamaré a mi clase ValueClass. ValueClass tiene unstd::unique_ptr como miembro privado e incluso me aseguro de que ValueClass no se pueda copiar extendiendonon_copyable que se parece a lo siguiente:

class non_copyable {
public:
    non_copyable() = default;
protected:
    virtual ~non_copyable() = default;
private:
    non_copyable(const non_copyable&) = delete;
    non_copyable& operator=(const non_copyable&) = delete;
};

Ahora estoy tratando de definir un std :: map usando mi clase como valor:

static std::map<int, ValueClass> value_classes = {
    {0, ValueClass()},
    {1, ValueClass() }
};

Obtengo un error de compilación comoinitializer_list intenta copiar esta clase.

He tratado de escribir mi propiamake_map funciona todo este fin de semana durante muchas horas para permitir la inicialización sin copiar, pero he fallado. He intentadoest, es yotr pero ninguno de ellos compila con Visual Studio 15.9.4.

¿Cómo puedo inicializar static std :: map donde la copia no está forzada y la inicialización está uniforme en una función, usando el compilador de Visual Studio?

EDITAR Aquí está la versión simplificada del escenario de la vida real donde estoy tratando de que esto funcione (perdóname por la falta de convenciones de nombres y la inconsistencia para los casos):

#include <iostream>
#include <map>

class non_copyable {
public:
    non_copyable() = default;
protected:
    virtual ~non_copyable() = default;
private:
    non_copyable(const non_copyable&) = delete;
    non_copyable& operator=(const non_copyable&) = delete;
};

class InnerValueClass : public non_copyable
{
public:
    InnerValueClass(const int inner_number) : inner_number_(inner_number) {  }
private:
    int inner_number_;
};

class ValueClass : public non_copyable
{
public:
    ValueClass(const int number1) : number1_(number1) {  }
    ValueClass(const bool condition) : condition_(condition), inner_value_(
        std::make_unique<InnerValueClass>(5)) {  }
private:
    int number1_{};
    bool condition_{};
    std::unique_ptr<InnerValueClass> inner_value_{};
};

/* Inline initialization of std::map copies, this is for initialization of non-copy types*/
template <typename TKey, typename TNonCopyableValue>
class make_map_by_moving
{
    typedef std::map<TKey, TNonCopyableValue> map_type;
    map_type map_;
public:
    make_map_by_moving(const TKey& key, TNonCopyableValue&& val)
    {
        map_.emplace(key, std::move(val));
    }
    make_map_by_moving<TKey, TNonCopyableValue>& operator()(const TKey& key, TNonCopyableValue&& val)
    {
        map_.emplace(key, std::move(val));
        return *this;
    }
    operator const map_type&()
    {
        return map_;
    }
};

static std::map<int, ValueClass> map =
        make_map_by_moving<int, ValueClass>
                (1, ValueClass(5))
                (2, ValueClass(true));
/* It goes on like this for hundreds of lines, so I really appreciate any
solution that leave me with a clean initialization rather than calling
functions on std::map */

int main() { }

Edición duplicada: La solución proporcionada en esa pregunta no funciona con la estructura de clases que tengo. También estoy buscando una solución para arreglarmake_map_by_moving función en otras palabras, una inicialización en línea, la respuesta siempre que haya una solución imprescindible con llamadas de función.