如何从c＆＃x2b;＆＃x2b;中的包装中删除元素？

Question

我正在尝试从C ++包中删除元素。很难用单词解释，所以我只会向您展示我想要的代码。

// lets say I have the following function
template<typename... Args>
void foo1(Args... arguments)
{
    // does something with the arguments
}

// and another similar function which needs to call foo1 but with a modified pack
template<typename... Args>
void foo2(Args... arguments)
{
   // foo2 figures out what arguments should be removed from the "arguments" pack
   // and here comes the hard part, after I know the indices of what elements to remove, how do I remove them from the pack?
   // then foo2 calls foo1 with the new pack (modified argument list)
   foo1(new_arguments...);
}

我想要一个纯的C ++解决方案，而无需包含任何文件，因为它应该适用于内核模式，并且您不能在内核模式下包含任何标准的C ++库。

有什么想法如何做？

编辑： 这些索引是constexpr整数值，因此我可以在模板或类似的内容中使用它们。

Answer 1

这是C ++ 20解决方案，无需使用任何标准库标头。

它定义了类型特质取，该从包装的前部收集n类型的列表，然后使用列表来定义lambda，该lambda分区foo2 并在每次递归中删除n th索引，直到在委派foo1委派之前，没有留下滴索引。

namespace detail {

template <class...>
struct list {};

template <int, class, class = list<>>
struct take;

template <class Drop, class Take>
struct take<0, Drop, Take> {
  using type = Take;
};

template <int N, class T, class... Drop, class... Take>
  requires(N > 0)
struct take<N, list<T, Drop...>, list<Take...>>
    : take<N - 1, list<Drop...>, list<Take..., T>> {};

}  // namespace detail

template <class... Args>
void foo2(Args... new_arguments) {
  foo1(new_arguments...);
}

template <int Index, int... Indices, class... Args>
void foo2(Args... arguments) {
  [&]<class... Take>(detail::list<Take...>) {
    [](Take... take, auto, auto... rest) {
      foo2<(Indices - 1)...>(take..., rest...);
    }(arguments...);
  }(typename detail::take<Index, detail::list<Args...>>::type{});
}

Answer 2

我找到了一个解决方案，这并不是我想要的，因为它使用std :: tuple，但现在已经足够了。这是代码：

#include <tuple>

struct remove_element_from_pack
{
private:
    template<typename Ty, typename... Args>
    __forceinline constexpr static Ty get_first_val(Ty val, Args... other) { return val; }

    template<typename Ty, typename... Args>
    __forceinline constexpr static auto remove_first_from_tuple(Ty first, Args... rest)
    {
        return std::tuple<Args...>(rest...);
    }

    template<typename return_ty, typename... Args>
    __forceinline constexpr static return_ty call_func_internal(const void* function, Args... arguments)
    {
        return ((return_ty(__fastcall*)(Args...))function)(arguments...);
    }

public:
    template<
        typename return_ty,
        int current_index,
        int remove_current,
        int... remove,
        typename current_ty,
        typename... All,
        typename... Processed>
        __forceinline static return_ty call_func(const void* function, std::tuple<current_ty, All...> all, std::tuple<Processed...> processed)
    {
        auto current = std::apply([](auto&&... args)->auto { return get_first_val(args...); }, all);

        // if there are no more elements
        if constexpr (!sizeof...(All))
        {
            // if we have to remove the current element
            if constexpr (remove_current != -1 && is_in_pack<int, current_index, remove_current, remove...>::value)
            {
                return std::apply(
                    [](auto &&... args)->return_ty { return call_func_internal<return_ty>(args...); },
                    std::tuple_cat(std::make_tuple(function), processed)
                );
            }
            else
            {
                return std::apply(
                    [](auto &&... args)->return_ty { return call_func_internal<return_ty>(args...); },
                    std::tuple_cat(std::make_tuple(function), std::tuple_cat(processed, std::make_tuple(current)))
                );
            }
        }
        else
        {
            auto new_all = std::apply([](auto&&... args)->auto { return remove_first_from_tuple(args...); }, all);

            // if we have to remove the current element
            if constexpr (remove_current != -1 && is_in_pack<int, current_index, remove_current, remove...>::value)
            {
                // if there are any elements left to remove
                if constexpr (sizeof...(remove) > 0)
                {
                    return std::apply(
                        [](auto &&... args)->return_ty { return call_func<return_ty, current_index + 1, remove...>(args...); },
                        std::tuple_cat(std::make_tuple(function), std::make_tuple(new_all), std::make_tuple(processed))
                    );
                }
                else
                {
                    return std::apply(
                        [](auto &&... args)->return_ty { return call_func<return_ty, current_index + 1, -1>(args...); },
                        std::tuple_cat(std::make_tuple(function), std::make_tuple(new_all), std::make_tuple(processed))
                    );
                }
            }
            else
            {
                auto new_processed = std::tuple_cat(processed, std::make_tuple(current));

                return std::apply(
                    [](auto &&... args)->return_ty { return call_func<return_ty, current_index + 1, remove_current, remove...>(args...); },
                    std::tuple_cat(std::make_tuple(function), std::make_tuple(new_all), std::make_tuple(new_processed))
                );
            }
        }
    }
};

然后您可以调用这样的函数：

// target function
int __fastcall add2(double a, double b)
{
    return a + b;
}

// call
remove_element_from_pack::call_func<int, 0, 0, 3>(
        add2, std::tuple<double, double, double, double>(20.0, 30.0, 40.0, 29.0), std::tuple()
    );

在此示例中，0和第三元素将从包中删除（函数调用中的第一个元组），这意味着20.0和<代码> 29.0 将被排除，add2将使用30.0和40.0来调用。

编辑：
我忘了发布该代码的这一部分：

template<typename Ty, Ty element, Ty first, Ty... rest_of_pack>
struct is_in_pack
{
private:
    __forceinline static constexpr bool get_value_internal()
    {
        if constexpr (first == element)
            return true;
        else if constexpr (!sizeof...(rest_of_pack))
            return false;
        else
            return is_in_pack<Ty, element, rest_of_pack...>::value;
    }

public:
    static constexpr const bool value = get_value_internal();
};