在Visual Studio 2012中不使用可变参数模板的情况下，emplace_back（）如何工作？

Question

Using Visual Studio 2012 with toolset v110 I can use container's emplace_back() function but can't use std::forward with variadic templates - accepting any amount of arguments. How is it done?

As example, make_unique<>() won't compile:

template<typename T, typename... Ts>
std::unique_ptr<T> make_unique(Ts&&... params)
{
  return std::unique_ptr<T>(new T(std::forward<Ts>(params)...));
}

Answer 1

According to this official list of supported C++11 language features, the variadic templates are not supported in VS 2012.

And there is the following note on the same page below:

Variadics: Visual C++ in Visual Studio 2012 had a scheme for simulating variadic templates. In Visual C++ in Visual Studio 2013, the simulations are gone and variadics are fully implemented. If your code relies on the old simulated variadics behavior, you have to fix it. However, the switch to real variadic templates has improved compile times and reduced compiler memory consumption.

And on another page there is this note telling how the simulation have been done:

Over the years, we've simulated variadic templates with two different systems of "faux variadic" preprocessor macros - the first system involved repeatedly including subheaders, while the second system (more elegant, as far as crawling horrors go) eliminated the subheaders and replaced them with big backslash-continued macros that were stamped out by other macros. Functions that were supposed to be true variadic, like make_shared(args...), were actually implemented with overloads: make_shared(), make_shared(arg0), make_shared(arg0, arg1), etc. Classes that were supposed to be true variadic, like tuple, were actually implemented with default template arguments and partial specializations. This allowed us to bring you make_shared/tuple/etc. years ago, but it had lots of problems. The macros were very difficult to maintain, making it hard to find and fix bugs in the affected code. Spamming out so many overloads and specializations increased compile times, and degraded Intellisense. Finally, there was the infinity problem. We originally stamped out overloads/specializations for 0 to 10 arguments inclusive, but as the amount of variadic machinery increased from TR1 through C++0x's evolution to C++11's final form, we lowered infinity from 10 to 5 in Visual C++ 2012 in order to improve compile times for most users (we provided a way to request the old limit of 10 through a macro, _VARIADIC_MAX).