Initialisieren Sie statische std :: map mit einem nicht kopierbaren Wert in einer einheitlichen Inline-Initialisierung

Ich möchte einen statischen std::map initialisieren, bei dem der Wert nicht kopierbar ist. Ich werde meine Klasse ValueClass nennen. ValueClass hat einen std::unique_ptr als privates Mitglied, und ich stelle sogar sicher, dass ValueClass nicht kopierbar ist, indem Sie non_copyable erweitern, der wie folgt aussieht:

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

Jetzt versuche ich eine std :: map mit meiner Klasse als Wert zu definieren:

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

Ich erhalte einen Kompilierungsfehler, da initializer_list versucht, diese Klasse zu kopieren.

Ich habe versucht, an diesem Wochenende über viele Stunden hinweg meine eigene make_map-Funktion zu schreiben, um die Initialisierung ohne Kopieren zu ermöglichen, aber ich bin fehlgeschlagen. Ich habe this , that und other ausprobiert, aber keiner von ihnen kann mit Visual Studio 15.9.4 kompilieren.

Wie kann ich statische std :: map initialisieren, wenn die Kopie nicht erzwungen wird und die Initialisierung in einer Funktion unter Verwendung des Visual Studio-Compilers vereinheitlicht wird?

EDIT: Hier ist die vereinfachte Version des realen Szenarios, in dem ich versuche, dies zum Laufen zu bringen.

#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() { }

Duplicate edit: Die in dieser Frage bereitgestellte Lösung funktioniert nicht mit der Klassenstruktur, die ich habe. Ich suche auch nach einer Lösung, um die make_map_by_moving-Funktion zu korrigieren, mit anderen Worten eine Inline-Initialisierung. Die Antwort gibt eine zwingende Lösung mit Funktionsaufrufen.