Gostaria de inicializar um @ estátistd::map onde o valor não é copiável. Vou ligar para a minha turma ValueClass. ValueClass tem umstd::unique_ptr como membro privado e até garanto que o ValueClass não pode ser copiado estendendonon_copyable que se parece com o seguinte:

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;
};

Agora estou tentando definir um std :: map usando minha classe como valor:

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

Eu recebo um erro de compilação comoinitializer_list tenta copiar esta classe.

Eu tentei escrever o meu própriomake_map funciona todo este fim de semana durante muitas horas para permitir a inicialização sem copiar, mas eu falhei. Eu tenteiist, aquel ede outro mas nenhum deles é compilado com o Visual Studio 15.9.

Como posso inicializar o std :: map estático no qual a cópia não é forçada e a inicialização é uniformizada em uma função, usando o compilador do Visual Studi

EDITARqui está a versão simplificada do cenário da vida real em que estou tentando fazer isso funcionar (desculpe-me por falta de convenção de nomenclatura e inconsistência nos 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() { }

Edição duplicada: A solução fornecida nessa pergunta não funciona com a estrutura de classes que tenho. Também estou procurando uma solução para corrigirmake_map_by_moving em outras palavras, uma inicialização em linha, a resposta é fornecida com uma solução imperativa com chamadas de funçã