C++11 特化一个版本的可变参数函数

Question

我正在尝试创建一个接受任意数量参数的可变参数函数，但我想专门介绍只传入两个带有迭代器的参数的情况。传入非迭代器的两个参数，仍应使用通用可变参数版本。我遇到了我无法克服的static_assert 失败。似乎它正在尝试评估 with_iterator_args 中的整个表达式，如果函数的参数少于两个，则会失败，而不是在检查 2 个参数时跳过对余数的评估。

有没有一种方法可以在不为一和二参数情况添加另外两个重载的情况下做到这一点？

这是我目前所拥有的：

#include <iostream>
#include <vector>
#include <tuple>

// inspired by https://stackoverflow.com/a/7943765/2129246
template <typename... Args>
struct args_traits
{
    enum { arity = sizeof...(Args) };

    template <size_t i>
    struct arg
    {
        typedef typename std::tuple_element<i, std::tuple<Args...>>::type type;
    };
};

// based on: https://stackoverflow.com/a/30766365/2129246
template <typename T>
struct is_iterator
{
    static char test(...);

    template <typename U,
        typename=typename std::iterator_traits<U>::difference_type,
        typename=typename std::iterator_traits<U>::pointer,
        typename=typename std::iterator_traits<U>::reference,
        typename=typename std::iterator_traits<U>::value_type,
        typename=typename std::iterator_traits<U>::iterator_category
    > static long test(U&&);

    constexpr static bool value = std::is_same<decltype(test(std::declval<T>())),long>::value;
};

template<typename Arg1, typename Arg2>
struct is_iterator_args
{
    constexpr static bool value = is_iterator<Arg1>::value && is_iterator<Arg2>::value;
};

template<typename... Args>
struct with_iterator_args
{
    constexpr static bool value = args_traits<Args...>::arity == 2
        && is_iterator_args<typename args_traits<Args...>::template arg<0>::type, typename args_traits<Args...>::template arg<1>::type>::value;
};

template <typename T, typename... Args,
    typename = typename std::enable_if<!with_iterator_args<Args...>::value>::type>
void some_func(T first, Args&&... args)
{
    std::cout << "func(" << first << ") called with " << sizeof...(args) << " args" << std::endl;
}

template <typename T, typename Begin, typename End,
    typename = typename std::enable_if<is_iterator_args<Begin, End>::value>::type>
void some_func(T first, Begin begin, End end)
{
    std::cout << "func(" << first << ") called with iterators: " << std::distance(begin, end) << std::endl;
}

int main()
{
    std::vector<int> v{1, 2, 3};

    some_func(1, v.begin(), v.end()); // special case, using iterators
    some_func(1, "arg2", 3, std::string("arg4"));
    some_func(1, "arg2");
    some_func(1);
    some_func(1, "arg2", 3, std::string("arg4"), 5.67);
    return 0;
}

这就是失败的原因：

In file included from test.cpp:3:
/usr/include/c++/9/tuple: In instantiation of ‘struct std::tuple_element<0, std::tuple<> >’:
/usr/include/c++/9/tuple:1285:12:   required from ‘struct std::tuple_element<1, std::tuple<const char (&)[5]> >’
test.cpp:14:69:   required from ‘struct args_traits<const char (&)[5]>::arg<1>’
test.cpp:45:3:   required from ‘constexpr const bool with_iterator_args<const char (&)[5]>::value’
test.cpp:49:37:   required by substitution of ‘template<class T, class ... Args, class> void some_func(T, Args&& ...) [with T = int; Args = {const char (&)[5]}; <template-parameter-1-3> = <missing>]’
test.cpp:68:21:   required from here
/usr/include/c++/9/tuple:1303:25: error: static assertion failed: tuple index is in range
 1303 |       static_assert(__i < tuple_size<tuple<>>::value,
      |                     ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~

Answer 1

您的问题是&& 之前和之后的表达式都必须编译 - 即使&& 之后的表达式不会被使用。

我的第一次尝试是利用 C++17 constexpr if。

template<typename... Args>
struct with_iterator_args
{
private:
    constexpr static bool value_checker() {
        if constexpr (args_traits<Args...>::arity == 2) {
            return is_iterator_args<typename args_traits<Args...>::template arg<0>::type, typename args_traits<Args...>::template arg<1>::type>::value;
        }
        else {
            return false;
        }
    }

public:
    constexpr static bool value = value_checker();
};

如果你需要坚持使用 C++11，你可以使用std::conditional。请注意，我也使用std::false_type 和std::true_type。

template<typename... Args>
struct is_iterator_args :
    std::conditional<is_iterator<typename args_traits<Args...>::template arg<0>::type>::value &&
                     is_iterator<typename args_traits<Args...>::template arg<1>::type>::value,
                    std::true_type, std::false_type>::type
{
};

template<typename... Args>
struct with_iterator_args :
     std::conditional<sizeof...(Args) == 2, is_iterator_args<Args...>, std::false_type>::type
{
};

Answer 2

我似乎只能通过添加更多重载来使其工作，而不是使用with_iterator_args：

template <typename T, typename... Args>
void some_func_common(T first, Args&&... args)
{
    std::cout << "func(" << first << ") called with " << sizeof...(args) << " args" << std::endl;
}

template <typename T, typename A>
void some_func(T first, A arg)
{
    some_func_common(first, arg);
}

template <typename T>
void some_func(T first)
{
    some_func_common(first);
}

template <typename T, typename A1, typename A2, typename... Args,
    typename = typename std::enable_if<!is_iterator_args<A1, A2>::value>::type>
void some_func(T first, A1 begin, A2 end, Args&&... args)
{
    some_func_common(first, std::forward<A1>(begin), std::forward<A2>(end), std::forward<Args>(args)...);
}

template <typename T, typename Begin, typename End,
    typename = typename std::enable_if<is_iterator_args<Begin, End>::value>::type>
void some_func(T first, Begin begin, End end)
{
    std::cout << "func(" << first << ") called iterators: " << std::distance(begin, end) << std::endl;
}

不过，这似乎是不必要的混乱。