Question

我有VariantType可以为空，即具有无效状态。

以下代码在使用Mingw Builds x64 5.3.0进行编译时会生成错误：

error: conversion from 'void' to non-scalar type 'VariantType {aka utils::Variant<bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >}' requested|

如何避免错误：

#include <Common/Variant.hpp>
using namespace utils;

#include <vector>
#include <unordered_map>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <map>

using VariantType = Variant<bool,int,std::string>;

class EFBase
{
public:
    virtual ~EFBase() {}
};

template<typename FuncSig>
class EF : public EFBase
{
public:

    EF(std::function<FuncSig> func) : m_function(func) {};

    std::function<FuncSig> m_function;
};

class Functions
{
public:

    using FuncMap = std::map<std::string,EFBase*>;

    FuncMap m_functions;

    template<typename FuncType>
    void Add(const std::string name, FuncType function)
    {
        m_functions.emplace(FuncMap::value_type(name,new EF<FuncType>(std::function<FuncType>(function))));
    }

    template<typename... Args>
    VariantType Invoke(const std::string& name, Args... args)
    {
        auto itr = m_functions.find(name);
        if(itr == m_functions.end())
            return VariantType();

        typedef void Func(typename std::remove_reference<Args>::type...);
        std::type_index index(typeid(Func));

        const EFBase& a = *itr->second;
        std::function<Func> func = static_cast<const EF<Func>&>(a).m_function;
        if(typeid(typename std::function<Func>::result_type) == typeid(void))
        {
            func(std::forward<Args>(args)...);
            return VariantType();
        }
        else
        {
            VariantType x = func(std::forward<Args>(args)...);
            return x;
        }
    }
};

int main()
{
    Functions f;
    f.Add<int(bool)>("get3",[](bool x) { return 3; });

    VariantType v = f.Invoke<>("get3",true);

    return 0;
}

我会认为检查函数对象的result_type就足够了;但我想这不是因为模板实例化。我是否需要一种辅助结构，在void情况下做一些不同的事情（基于模板参数）？

代码的目的是按名称在地图中存储任意签名的功能，以便以后可以调用它们。 VariantType处理多个可能的返回值。

错误发生在else方法的Invoke块中的分配上。

VariantType是相当多的代码，所以我没有提供它（我不确定它是否相关）。但如果需要，我可以。

Answer 1

根据确切的用例，一个建议是将std::function<VariantType(x)>存储在地图中（x是一些固定的参数集），并认为这些功能将适用于使用functor包装器进行存储的特定签名。然后，传递给Add的客户端函数将（a）需要包含在具有正确签名的函子中，或者（b）如果您知道将传递给{{的所有不同类型的函数1}}，您可以定义Add，并根据template<typename F, typename ...Args> Add(F f)对其进行专门化，以便std::result_of<F(...Args)>可以创建包装器。您还可以执行混合方法，并要求客户端传递符合固定参数列表的函数，Add可以根据传入函数的返回类型将这些函数包装为返回Add。 / p>

下面是一个示例，展示了一些概念。

注意SFINAE原则应用于VariantType模板重载，以避免编译器在我们不希望它评估的特化中失败（wrapper返回f的那个}）。

另请注意，我认为实际上需要在运行时根据函数类型调度不同的参数列表的情况可能要困难得多，因此这里的方法尝试通过在创建时捕获它们来规范化参数列表。打回来。如果你真的认为你需要void中的可变参数列表，那么我建议可能会考虑使用Invoke来包装这些函数，或者至少是为了概念性指导。

boost::any

输出：

#include <iostream>
#include <type_traits>
#include <functional>
#include <string>
#include <map>
#include <vector>

template<typename T1, typename T2, typename T3>
struct Variant
{
    Variant() { std::cout << "In void Ctor of Variant" << std::endl; }
    template<typename T> Variant(T t) { std::cout << "In data Ctor of Variant" << std::endl; }
};

using VariantType = Variant<bool,int,std::string>;
using FuncSig = std::function<VariantType(int)>;


struct Functions
{
    template<typename F, typename Result = typename std::result_of<F(int)>::type >
    void Add(const std::string name, F f)
    {
        this->m_functions.emplace(name, [=](int i) { return wrapper<F, Result>(f, i); });
    }

    VariantType Invoke(const std::string& name, int i)
    {
        auto itr = m_functions.find(name);
        if(itr == m_functions.end())
            return VariantType();

        return itr->second(i);
    }
private:
    using FuncMap = std::map<std::string,FuncSig>;
    FuncMap m_functions;

    template<typename F, typename ReturnValue, typename ...Args>
    static typename std::enable_if<!std::is_same<ReturnValue, void>::value, VariantType>::type wrapper(F f, Args&&... args)
    {
        VariantType x = f(std::forward<Args>(args)...);
        return x;
    }

    template<typename F, typename ReturnValue, typename ...Args>
    static typename std::enable_if<std::is_same<ReturnValue, void>::value, VariantType>::type wrapper(F f, Args&&... args)
    {
        f(std::forward<Args>(args)...);
        return VariantType();
    }
};

struct Client
{
    Client(Functions& funcs)
    {
        funcs.Add("v_func", [&](int i) { this->v_func(this->d, i); } );
        funcs.Add("b_func", [&](int i) { return this->b_func(i); } );
        funcs.Add("s_func", [&](int i) { return this->s_func(i, this->some_string); } );
        funcs.Add("i_func", [&](int i) { return this->i_func(i); } );
    }

    void v_func(double d, int i) const { std::cout << this->obj_name << ": v_func()" << d << ", " << i << std::endl; }
    bool b_func(int i) const { std::cout << this->obj_name << ": b_func()" << i << std::endl; return i > 5; }
    std::string s_func(int i, std::string const& s) const { std::cout << this->obj_name << ": s_func()" << i << ", " << s << std::endl; return s; }
    int i_func(int i) const { std::cout << this->obj_name << ": i_func()" << i << std::endl; return i + 10; }

    std::string obj_name;
    const std::string some_string = "some_string";
    const double d = 3.14;
};

int main()
{
    VariantType variant;
    Functions functions;
    Client c(functions);
    c.obj_name = "Client1";
    std::vector<std::string> v = { "s_func", "b_func", "v_func", "i_func" };
    int i = 0;
    for (auto s : v) { variant = functions.Invoke(s, i++); }

    return 0;
}

Answer 2

（对于这篇文章，'生成代码'意味着执行类型替换，选择专业化等等）

是;如果要根据模板参数的属性生成不同的代码，则需要使用专门化。

在永不执行的块中隐藏代码会阻止执行，但不会阻止代码生成。

它不一定是辅助结构;你可以使用标签：

VariantType InvokeHelper(/* args here */, std::true_type) ;
VariantType InvokeHelper(/* args here */, std::false_type) ;

// ...
return InvokeHelper(/* */, std::is_same</* function result*/, void>);

但帮助结构可能是更好的选择。

如何避免此代码中的void赋值？

2 个答案: