Std::map::emplace

#include<map>
struct test
{
    test(int,int){}
    test(const test&)=delete;
    test(test&&)=delete;
    int x,y;
};
 
int main()
{
    std::map<int,test>my_map;
    my_map.emplace(0,0,0);
}

namespace std
{
template<>
struct pair<const int,::test>
{
    typedef const int first_type;
    typedef test second_type;
    pair(int a,int b,int c):first(a),second(b,c){}
    const int first;
    test second;
};
}

#include<map>
#include<utility>
#include <functional>
struct test
{
    test(int,int){}
    //test(const test&)=delete;
    //test(test&&)=delete;
    int x,y;
};
 
int main()
{
    std::map<int,test> my_map;
    my_map.emplace(2,
      test(3,10)
    );
}

#include<map>
#include<utility>
struct test
{
    test(int,int){}
    test(const test&)=delete;
    test(test&&)=delete;
    int x,y;
};
 
int main()
{
    std::map<int,test> my_map;
    my_map.emplace(
      std::piecewise_construct,
      std::forward_as_tuple(10),
      std::forward_as_tuple(3,10)
    );
}

template<typename... _Args>
    std::pair<iterator, bool>
    emplace(_Args&&... __args)

template<typename type1,typename type2,typename type3>
    std::pair<iterator, bool>
    emplace(type1&&arg1,type2&&arg2,type3&&arg3)

struct test
{
    test(int){}
    test(int,int){}
    test(int,int, int){}
};

std::map<test, test> mp;
mp.emplace(1, 2, 3, 4);

#include<map>
int main() {
    std::map<int,int> my_map;
    my_map.emplace(1, 1);
}

#include<map>
struct test
{
    test(int){}
    test(const test&)=delete;
    test(test&&)=delete;
    int x,y;
};
 
int main()
{
    std::map<int,test> my_map;
    my_map.emplace(1,2);
}

      template<typename _Up, typename... _Args>
        void
        construct(_Up* __p, _Args&&... __args)
    { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }

std::pair<int, test>(
      std::piecewise_construct,
      std::forward_as_tuple(10),
      std::forward_as_tuple(3,10));

#include<map>
struct test
{
    test(int){}
    test(const test&)=delete;
    test(test&&)=delete;
    int x,y;
};
 
//явно прописываем pair конструктор работающий без временных объектов
namespace std
{
template<>
struct pair<const int,::test>
{
    typedef const int first_type;
    typedef test second_type;
    pair(int a,int b):first(a),second(b){}
    const int first;
    test second;
};
}
 
int main()
{
    std::map<int,test>my_map;
    my_map.emplace(0,0);//вуаля, piecewise_construct не используется, а не копируемый объект создается
}

#include <iostream>
#include <vector>
#include <tuple>
 
class test 
{
public:
   test(int, std::string, int) {}
};
 
int main()
{
   std::vector<test> v;
   v.emplace_back(1, "hello", 2);
   std::vector<std::pair<int, test>> vec;
   vec.emplace_back(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(1, "hello", 2));
}

#include<map>
#include<iostream>
struct test
{
    test(int) {
        std::cout << "test(int)\n";
    }
    test(const test&) {
        std::cout << "test(const test&)\n";
    };
    test(test&&){
        std::cout << "test(test&&)\n";
    };
    int x,y;
};
 
//явно прописываем pair конструктор работающий без временных объектов
namespace std
{
    template<>
    struct pair<const int,::test>
    {
        typedef const int first_type;
        typedef test second_type;
        pair(int a,second_type b):first(a),second(b){
            std::cout << "pair(int, second_type)\n";
        }
        const int first;
        test second;
    };
}
 
int main()
{
    std::map<int,test>my_map;
    my_map.emplace(0,0);//вуаля, piecewise_construct не используется, а не копируемый объект создается
 
}

#include<map>
#include<iostream>
#include<map>
struct test
{
    test(int) {}
    test(int, int) {}
    test(const test&) = delete;
    test(test&&) = delete;
    int x,y;
};
 
int main()
{
    std::map<int,test>my_map;
    my_map.emplace(
      std::piecewise_construct,
      std::forward_as_tuple(10),
      std::forward_as_tuple(3,10)
    );
    my_map.insert(my_map.begin(), {0,1});
}

#include <functional>
//функция принимает один аргумент
template<typename type>
void test(type&&){}
int main()
{
    //функции передается один аргумент. Несмотря на то что в tuple их десяток
    test(std::forward_as_tuple(0,1,2,3,4,5,6,7,8,9));
}