error: use of deleted function 'constexpr std::pair<_T1, _T2>::pair(const std::pair<_T1, _T2>&) [with _T1 = const int; _T2 = std::unique_ptr<X>]

m[a] = {};

m[a].clear();

map<int,unique_ptr<X>> default_constructed; // OK
map<int,unique_ptr<X>> & mm = a[m]; // OK
mm = default_constructed; // нельзя, т.к. unique_ptr<X>::operator=() = delete;

void f(std::map<int, std::map<int,std::unique_ptr<X>>>& m, int a, int b, X x)
{
    auto &mm = m[a];
    mm[b] = std::make_unique<X>(x);
// или даже так
    m[a][b] = std::make_unique<X>(x);
}

class X {
};

struct Key
{
    int a;
    int b;

    bool operator==(Key const& key) const
    {
        return a == key.a && b == key.b;
    }
    
    struct hash
    {
        size_t operator()(Key const& key) const
        {
            std::hash<int> const hasher;
            return hasher(key.a) ^ hasher(key.b);
        }
    };
};

using Map = std::unordered_map<Key, X, Key::hash>;

void f(Map& m, int a, int b, X x)
{
    m[Key{a, b}] = std::move(x);
}

struct X
{
    struct Key
    {
        int a;
        int b;
    };

    // object order
    friend bool operator<(X const& x1, X const& x2)
    {
        return std::tie(x1.key_a, x1.key_b) < std::tie(x2.key_a, x2.key_b);
    }

    // transparent less<> for heterogenous lookup    
    friend bool operator<(X const& x, X::Key const& key)
    {
        return std::tie(x.key_a, x.key_b) < std::tie(key.a, key.b);
    }
    friend bool operator<(X::Key const& key, X const& x)
    {
        return std::tie(key.a, key.b) < std::tie(x.key_a, x.key_b);
    }
    
    int key_a;
    int key_b;
    std::string payload;
};

int main()
{
    std::set<X, std::less<>> xs;
    xs.emplace(X{ 1, 2, "large data" });
    xs.emplace(X{ 3, 4, "large data2" });

    auto it = xs.find(X::Key{ 1, 2 });
    std::cout << "{1, 2}: " << it->payload << '\n';
    assert(it->payload == "large data");

    auto it2 = xs.find(X::Key{ 3, 4 });
    std::cout << "{3, 4}: " << it2->payload << '\n';
    assert(it2->payload == "large data2");

    auto it3 = xs.find(X::Key{ 1, 3 });
    assert(it3 == xs.end());
}

PM>>void f(std::map<int, std::map<int,std::unique_ptr<X>>>& m, int a, int b, X x)
PM>>{
PM>>    m[a][b] = std::make_unique<X>(x);
PM>>}
PM>>

void f(std::array<std::array<X, 10>, 10>& matrix, int a, int b, X x)
//     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ читать примерно как X matrix[10][10]
{
   m[a][b] = x;
}

X_impl* get_some_X(IComObject* obj);

class X
{
    X_impl* _impl;
public:
   explicit X(IComObject* from_obj)
     : _impl(get_some_X(from_obj)
   {
   }

   void do() { some comlex use of _impl; }
};

class X
{
    std::unique_ptr<X_impl> _impl;
public:
   explicit X(IComObject* from_obj) 
     : _impl(get_some_X(from_obj)
   {
   }

   // если объявлен пользовательский конструктор, то версия по умолчанию сгегерирована не будет
   // но мы можем явно указать компилятору, чтобы он это сделал
   X() = default;

   // копирование будет запрещено из-за некопируемости unique_ptr _impl,
   // но перемещение пусть тоже генерирует компилятор
   X(X&&) = default;
   X& operator=(X&&) = default;
};

#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <cassert>

class X
{
    std::unique_ptr<std::string> impl_;
public:
    explicit X(std::string const& payload)
        : impl_(std::make_unique<std::string>(payload))
    {
    }
    
    // перемещение все-таки понадобится 
    X(X&&) = default;
    X& operator=(X&&) = default;
    
    std::string const& payload() const { return *impl_; }
};

int main()
{
    std::map<int, std::map<int, X>> m;
    
    // В С++17 есть такой аналог operator[]
    bool inserted = m[1].insert_or_assign(2, X("data")).second;
    assert(inserted);
    inserted = m[1].insert_or_assign(2, X("data2")).second;
    assert(!inserted);

    X const& assigned_x2 = m.at(1).at(2);
    assert(assigned_x2.payload() == "data2");

    auto &mm = m[2];
    inserted = mm.emplace(4, X("data3")).second;
    assert(inserted);
    inserted = mm.emplace(4, X("data4")).second;
    assert(!inserted);
    
    X const& inserted_x4 = mm.at(4);
    assert(inserted_x4.payload() == "data3");
    
    std::cout << m.at(1).at(2).payload() << '\n';

    auto it = m.find(2);
    auto iit = it->second.find(4);
    std::cout << iit->second.payload() << '\n';

    it = m.find(99);
    assert(it == m.end());
}

auto it = map.insert({ 1, X{} });  // создается pair{1, X} и перемещается в map
auto it2 = map.insert({ 1, X{} }); // создается pair{1, X} но такой ключ уже есть, только что созданный pair{1, X} уничтожается 

auto it = map.emplace(1, X_args); // find(1) не находит элемент, создается узел в дереве, значение X конструируется из аргументов в созданном узле дерева
auto it2 = map.emplace(1, X_args); // find(1) находит элемент, возвращает итератор на него

map:::mapped_type map::at(key_type const& key)
{
    auto it = find(key);
    if (it == end()) throw std::out_of_range;
    return it->second;
}

auto it = map.find(key);
if (it == map.end())
{
    it = map.insert(pair(key, X(ctor_arg1, .. ctor_argN)));
}

//  или 
it = map.try_emplace(key, ctor_arg1, .. ctor_argN);