Question

考虑以下简化的变体类代码。其中大部分内容仅供参考，问题与conditional_invoke方法有关。

// Possible types in variant.
enum class  variant_type { empty, int32, string };

// Actual data store.
union variant_data { 
    std::int32_t val_int32;
    std::string val_string;
    inline variant_data(void) { /* Leave uninitialised */ }
    inline ~variant_data(void) { /* Let variant do clean up. */ }
};

// Type traits which allow inferring which type to use (these are actually generated by a macro).
template<variant_type T> struct variant_type_traits { };
template<class T> struct variant_reverse_traits { };

template<> struct variant_type_traits<variant_type::int32> {
    typedef std::int32_t type;
    inline static type *get(variant_data& d) { return &d.val_int32; }
};

template<> struct variant_reverse_traits<std::int32_t> {
    static const variant_type type = variant_type::int32;
    inline static std::int32_t *get(variant_data& d) { return &d.val_int32; }
};

template<> struct variant_type_traits<variant_type::string> {
    typedef std::string type;
    inline static type *get(variant_data& d) { return &d.val_string; }
};

template<> struct variant_reverse_traits<std::string> {
    static const variant_type type = variant_type::string;
    inline static std::string *get(variant_data& d) { return &d.val_string; }
};

// The actual variant class.
class variant {
public:

    inline variant(void) : type(variant_type::empty) { }

    inline ~variant(void) {
        this->conditional_invoke<destruct>();
    }

    template<class T> inline variant(const T value) : type(variant_type::empty) {
        this->set<T>(value);
    }

    template<class T> void set(const T& value) {
        this->conditional_invoke<destruct>();
        std::cout << "Calling data constructor ..." << std::endl;
        ::new (variant_reverse_traits<T>::get(this->data)) T(value);
        this->type = variant_reverse_traits<T>::type;
    }

    variant_data data;
    variant_type type;

    private:

    template<variant_type T> struct destruct {
        typedef typename variant_type_traits<T>::type type;
        static void invoke(type& v) {
            std::cout << "Calling data destructor ..." << std::endl;
            v.~type(); 
        }
    };

    template<template<variant_type> class F, class... P>
    inline void conditional_invoke(P&&... params) {
        this->conditional_invoke0<F, variant_type::int32, variant_type::string, P...>(std::forward<P>(params)...);
    }

    template<template<variant_type> class F, variant_type T, variant_type... U, class... P>
    void conditional_invoke0(P&&... params) {
        if (this->type == T) {
            F<T>::invoke(*variant_type_traits<T>::get(this->data), std::forward<P>(params)...);
        }
        this->conditional_invoke0<F, U..., P...>(std::forward<P>(params)...);
    }

    template<template<variant_type> class F, class... P>
    inline void conditional_invoke0(P&&... params) { }
};

代码以这种方式工作，即只要仿函数的参数列表P...为空，它就可以工作。如果我添加另一个仿函数，如

template<variant_type T> struct print {
    typedef typename variant_type_traits<T>::type type;
    static void invoke(type& v, std::ostream& stream) {
        stream << v;
    }
};

并尝试调用它

friend inline std::ostream& operator <<(std::ostream& lhs, variant& rhs) {
    rhs.conditional_invoke<print>(lhs);
    return lhs;
}

编译器VS 20115抱怨

错误C2672：'variant :: conditional_invoke0'：找不到匹配的重载函数

分别是

或gcc

错误：没有匹配函数来调用'variant :: conditional_invoke0＆gt;＆amp;＆gt;（std :: basic_ostream＆amp;）'

我猜编译器无法确定U...何时结束以及P...何时开始。有没有办法解决这个问题？

Answer 1

您必须使两个参数包都可以推断。也就是说，让type和non-type模板参数成为函数参数列表的一部分。为此，引入虚拟结构：

template <variant_type...>
struct variant_type_list {};

让编译器从函数调用中推导出variant_type...包：

template <template <variant_type> class F
        , variant_type T
        , variant_type... U
        , typename... P>
void conditional_invoke0(variant_type_list<T, U...> t
                       , P&&... params)
{
    if (this->type == T)
    {
        F<T>::invoke(*variant_type_traits<T>::get(this->data)
                    , std::forward<P>(params)...);
    }

    this->conditional_invoke0<F>(variant_type_list<U...>{}
                               , std::forward<P>(params)...);
}

要中断递归调用，请引入一个空variant_type_list的重载：

template <template <variant_type> class F, typename... P>
void conditional_invoke0(variant_type_list<>, P&&... params) {}

第一次调用调用者时，请提供variant_types作为参数：

this->conditional_invoke0<F>(variant_type_list<variant_type::int32, variant_type::string>{}
                           , std::forward<P>(params)...);

DEMO

带有多个参数包的C ++方法

1 个答案: