過濾

Question

我要「過濾器」就像在下面的代碼的可變參數模板函數的參數包（需要「過濾器」只有某些類型的變量）：

#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中的成員函數具有更高的優先級。因此在這裏沒有發生過濾。

有什麼解決方法嗎？

Answer 1

這應該做的伎倆：

#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; 
}