// And let's use our `forArgs` function to print
// the indices:
static void print()
{
forArgs
(
[](auto x){ std::cout << x << " "; },
// We can expand the matched indices here:
TIs...
);
}
constexpr decltype(auto) forTuple(
TFunction&& mFunction, TTuple&& mTuple)
{
return tupleApply(
[&mFunction](auto&&... xs)
{
forArgs(mFunction, ECS_FWD(xs)...);
},
ECS_FWD(mTuple));
}
void chain(TF&& mFn, TArgs&&... mArgs)
{
forArgs(
[mFn](auto& mCont)
{
for(auto& x : mCont) mFn(x);
},
std::forward<TArgs>(mArgs)...);
}
auto make_vector(TArgs&&... mArgs)
{
// First problem: what type should we return?
// We need to deduce a type suitable for all the
// passed arguments.
// `std::common_type_t` comes into play here.
// Note:
//
// * C++14 added many versions of commonly used
// type traits functions ending with "_t", that
// do not require the user to write `typename`
// at the beginning and `::type` at the end.
//
// * C++11:
// using IntPtr = typename std::add_pointer<int>::type;
//
// * C++14:
// using IntPtr = std::add_pointer_t<int>;
//
// `std::common_type_t` determines the common type among all
// passed types - that is the type all passed types can be
// implicitly converted to.
// Computing the correct return type is now easy:
using VectorItem = std::common_type_t<TArgs...>;
std::vector<VectorItem> result;
// We also know how many items we're going to put into
// the vector - we can actually reserve the memory beforehand
// as a small optimization.
result.reserve(sizeof...(TArgs));
// Now we use `forArgs` to generate the code that emplaces
// the items into our vector:
forArgs(
// Our lambda needs to capture the vector and use
// an "universal reference" to correctly forward
// the passed argument to `std::vector::emplace_back`.
[&result](auto&& x)
{
// We do not know the type of `x` - but we can
// retrieve it using `decltype(x)`.
result.emplace_back(std::forward<decltype(x)>(x));
},
std::forward<TArgs>(mArgs)...);
return result;
}
int main()
{
forArgs(
[](const auto& x){ std::cout << x << std::endl; },
"hello",
1,
2,
3
);
return 0;
}
auto make_vector(TArgs&&... mArgs)
{
using VectorItem = std::common_type_t<TArgs...>;
std::vector<VectorItem> result;
result.reserve(sizeof...(TArgs));
forArgs(
[&result](auto&& x)
{
result.emplace_back(std::forward<decltype(x)>(x));
},
std::forward<TArgs>(mArgs)...);
return result;
}
