2

次のコードのように、可変個引数テンプレート関数のパラメーター パックを「フィルター処理」したい (特定の型の変数のみを「フィルター処理」する必要がある)。

#include <iostream>
#include <utility>
#include <cstdlib>

struct Z {};

struct test
{

    using result_type = void;

    template< typename... P >
    result_type apply_filter(P &&... _p) const
    {
        using std::forward;
        return operator () (forward< P >(_p)...);
    }

    template< typename... T >
    result_type operator () (std::string const & _s, T &&... _tail) const
    {
        std::cout << _s << std::endl;
        return operator () (std::forward< T >(_tail)...);
    }

    template< typename... T >
    result_type operator () (double const & _x, T &&... _tail) const
    {
        std::cout << _x << std::endl;
        return operator () (std::forward< T >(_tail)...);
    }

    template< typename... T >
    result_type operator () (Z const &, T &&... _tail) const
    {
        std::cout << "z" << std::endl;
        return operator () (std::forward< T >(_tail)...);
    }

private :

    result_type operator () () const { return; }

    template< typename T, typename U >
    using is_the_same = std::is_same< typename std::remove_const< typename std::remove_reference< T >::type >::type, U >;

    template< typename T >
    typename std::enable_if< is_the_same< T, std::string >::value, std::string >::type
    forward(T && _s) const
    {
        return "\"" + _s + "\"";
    }

    template< typename T >
    typename std::enable_if< is_the_same< T, double >::value, double >::type
    forward(T && _x) const
    {
        return _x + 1.0;
    }

};

int main()
{
    test test_;
    double x = 0.0;
    std::string s = "s";
    Z z;
    test_.apply_filter(x, s, z);
    return EXIT_SUCCESS;
}

ただしstd::forward、 のメンバー関数よりも優先度が高くなりますapply_filter。したがって、ここではフィルタリングは行われません。

回避策はありますか？

4

1 に答える 1

2

これでうまくいくはずです：

#include <iostream>
#include <utility>

struct Z { };

struct test
{

    using result_type = void;

    template< typename... P >
    result_type apply_filter(P &&... _p) const
    {
        return operator () (forward<P>(_p)...);
    }

    template< typename... T >
    result_type operator () (std::string const & _s, T &&... _tail) const
    {
        std::cout << _s << std::endl;
        return operator () (std::forward< T >(_tail)...);
    }

    template< typename... T >
    result_type operator () (double const & _x, T &&... _tail) const
    {
        std::cout << _x << std::endl;
        return operator () (std::forward< T >(_tail)...);
    }

    template< typename... T >
    result_type operator () (Z const &, T &&... _tail) const
    {
        std::cout << "z" << std::endl;
        return operator () (std::forward< T >(_tail)...);
    }

private:

    result_type operator () () const { }

    template< typename T, typename U >
    using is_the_same = std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, U>;

    template<typename T>
    using is_known_type = typename std::conditional<(is_the_same<T, std::string>::value || is_the_same<T, double>::value), std::true_type, std::false_type>::type;

    template<typename T>
    typename std::enable_if<is_the_same<T, std::string>::value, std::string>::type
    forward_impl(T && _s, std::true_type) const
    {
        return "\"" + _s + "\"";
    }

    template<typename T>
    typename std::enable_if<is_the_same<T, double>::value, double>::type
    forward_impl(T && _x, std::true_type) const
    {
        return _x + 1.0;
    }

#define RETURNS(exp) -> decltype(exp) { return exp; }

    template<typename T>
    auto forward_impl(T && t, std::false_type) const
    RETURNS(std::forward<T>(t))

    template<typename T>
    auto forward(T && t) const
    RETURNS(forward_impl(std::forward<T>(t), is_known_type<T>()))

#undef RETURNS
};

int main(int argc, char ** argv) {
    test test_;
    double x = 0.0;
    std::string s = "s";
    Z z;
    test_.apply_filter(x, s, z);

    return 0;
}
于 2013-08-17T20:47:47.223 に答える