ел бы инициализировать статическийstd::map где значение не подлежит копированию. Я позвоню своему классуValueClass. ValueClass имеетstd::unique_ptr как частный член, и я даже гарантирую, что ValueClass не будет копироваться путем расширенияnon_copyable это выглядит следующим образом:

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

Теперь я пытаюсь определить std :: map, используя мой класс в качестве значения:

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

Я получаю ошибку компиляции какinitializer_list пытается скопировать этот класс.

Я пытался написать свой собственныйmake_map Работать целыми в эти выходные в течение многих часов, чтобы включить инициализацию без копирования, но мне не удалось. я пробовалэто, это а такжеДругие но ни один из них не компилируется с Visual Studio 15.9.4.

Как я могу инициализировать статический std :: map, где копирование не принудительно, и инициализация унифицирована в одной функции, используя компилятор Visual Studio?

РЕДАКТИРОВАТЬ: Вот упрощенная версия сценария реальной жизни, где я пытаюсь заставить это работать (извините за отсутствие соглашения об именах и непоследовательность для случаев):

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

Дубликат редактировать: Решение, предоставленное в этом вопросе, не работает со структурой классов, которые у меня есть. Я также ищу решение, чтобы исправитьmake_map_by_moving функция, другими словами, встроенная инициализация, ответ при условии, что есть императивное решение с вызовами функций.