Подумайте о написании общей заводской функции, которая возвращает объект для недавно построенного общего типа. Такие фабрично-заводские функции ценны для инкапсуляции и локализации распределения ресурсов. Очевидно, что фабричная функция должна принимать точно такие же наборы аргументов, как и конструкторы типа построенных объектов:

template<class T> T* factory_new()
{  return new T();  }
template<class T> T* factory_new(a1)
{  return new T(a1);  }
template<class T> T* factory_new(a1, a2)
{  return new T(a1, a2);  }

К сожалению, в C++03 гораздо большая проблема с этим подходом заключается в том, что в случае N-аргумента потребуются перегрузки 2N, что сразу же исключает это как общее решение. К счастью, большинство конструкторов принимают аргументы по стоимости, по конст-ссылке или по rvalue-ссылке. Если эти ограничения приняты, пересылочная эмуляция дела N-аргумента требует только N перегрузок. Эта библиотека облегчает эту эмуляцию с помощью<BOOST_FWD_REF>и<boost::forward>:

#include <boost/move/utility_core.hpp>
#include <iostream>
class copyable_only_tester
{
   public:
   copyable_only_tester()
   {  std::cout << "copyable_only_tester()" << std::endl;   }
   copyable_only_tester(const copyable_only_tester&)
   {  std::cout << "copyable_only_tester(const copyable_only_tester&)" << std::endl;   }
   copyable_only_tester(int)
   {  std::cout << "copyable_only_tester(int)" << std::endl;   }
   copyable_only_tester(int, double)
   {  std::cout << "copyable_only_tester(int, double)" << std::endl;   }
};
class copyable_movable_tester
{
   // move semantics
   BOOST_COPYABLE_AND_MOVABLE(copyable_movable_tester)
   public:
   copyable_movable_tester()
   {  std::cout << "copyable_movable_tester()" << std::endl;   }
   copyable_movable_tester(int)
   {  std::cout << "copyable_movable_tester(int)" << std::endl;   }
   copyable_movable_tester(BOOST_RV_REF(copyable_movable_tester))
   {  std::cout << "copyable_movable_tester(BOOST_RV_REF(copyable_movable_tester))" << std::endl;   }
   copyable_movable_tester(const copyable_movable_tester &)
   {  std::cout << "copyable_movable_tester(const copyable_movable_tester &)" << std::endl;   }
   copyable_movable_tester(BOOST_RV_REF(copyable_movable_tester), BOOST_RV_REF(copyable_movable_tester))
   {  std::cout << "copyable_movable_tester(BOOST_RV_REF(copyable_movable_tester), BOOST_RV_REF(copyable_movable_tester))" << std::endl;   }
   copyable_movable_tester &operator=(BOOST_RV_REF(copyable_movable_tester))
   {  std::cout << "copyable_movable_tester & operator=(BOOST_RV_REF(copyable_movable_tester))" << std::endl;
      return *this;  }
   copyable_movable_tester &operator=(BOOST_COPY_ASSIGN_REF(copyable_movable_tester))
   {  std::cout << "copyable_movable_tester & operator=(BOOST_COPY_ASSIGN_REF(copyable_movable_tester))" << std::endl;
      return *this;  }
};
//1 argument
template<class MaybeMovable, class MaybeRv>
void function_construct(BOOST_FWD_REF(MaybeRv) x)
{  MaybeMovable m(boost::forward<MaybeRv>(x));   }
//2 argument
template<class MaybeMovable, class MaybeRv, class MaybeRv2>
void function_construct(BOOST_FWD_REF(MaybeRv) x, BOOST_FWD_REF(MaybeRv2) x2)
{  MaybeMovable m(boost::forward<MaybeRv>(x), boost::forward<MaybeRv2>(x2));  }
int main()
{
   copyable_movable_tester m;
   //move constructor
   function_construct<copyable_movable_tester>(boost::move(m));
   //copy constructor
   function_construct<copyable_movable_tester>(copyable_movable_tester());
   //two rvalue constructor
   function_construct<copyable_movable_tester>(boost::move(m), boost::move(m));
   copyable_only_tester nm;
   //copy constructor (copyable_only_tester has no move ctor.)
   function_construct<copyable_only_tester>(boost::move(nm));
   //copy constructor
   function_construct<copyable_only_tester>(nm);
   //int constructor
   function_construct<copyable_only_tester>(int(0));
   //int, double constructor
   function_construct<copyable_only_tester>(int(0), double(0.0));
   //Output is:
   //copyable_movable_tester()
   //copyable_movable_tester(BOOST_RV_REF(copyable_movable_tester))
   //copyable_movable_tester()
   //copyable_movable_tester(const copyable_movable_tester &)
   //copyable_movable_tester(BOOST_RV_REF(copyable_movable_tester), BOOST_RV_REF(copyable_movable_tester))
   //copyable_only_tester()
   //copyable_only_tester(const copyable_only_tester&)
   //copyable_only_tester(const copyable_only_tester&)
   //copyable_only_tester(int)
   //copyable_only_tester(int, double)
   return 0;
}

Пересылка конструкторов удобна для реализации вставки размещения в контейнерах с только N перегрузками, если реализатор принимает ограничения этого типа пересылки для компиляторов C++03. В компиляторах с rvalue-ссылками достигается совершенная пересылка.