使用指向部分专用函数成员的指针自动填充向量

时间:2015-04-19 17:21:52

标签: c++ templates c++11 function-pointers function-signature

我正在研究类似管道的设计模式。我的设计目标之一是通过提供指向某个数据类的函数成员的指针来启用管道段的动态链接。

每个数据类都有一组使用整数模板参数索引的函数成员(表示数据类输出端口)。这些函数使用关键字auto动态推导出返回类型,但所有函数都接受相同的整数参数c_Idx,即template <int N> auto getOutput(int c_Idx) const。与每个函数getOutput相关联的功能(由用户)在一组部分专用结构getOutputImpl中定义。因此,每个数据类可以具有1到一些固定数量K的输出数据端口。

为了允许以通用方式在管道段之间进行动态链接,它们可以存储在std::vector<boost::any>类型的容器中。但是,我需要能够自动使用指向函数成员模板的指针来填充此向量。

手动实现的示例如下所示

template<class TLeafType>
class AlgorithmOutput
{

protected:

    std::vector<boost::any> OutputPorts;

public:

    AlgorithmOutput()
        {

            //////////////////////////////////////////
            // This procedure needs to be automated //
            //////////////////////////////////////////
            std::function<std::unique_ptr<double>(int)> pOutFun1 = std::bind(
                std::mem_fn(
                    true ? &AlgorithmOutput<TLeafType>::getOutput<0> : nullptr
                    ),
                this,
                std::placeholders::_1
                );
            OutputPorts.push_back(pOutFun1);

            std::function<std::unique_ptr<int>(int)> pOutFun2 = std::bind(
                std::mem_fn(
                    true ? &AlgorithmOutput<TLeafType>::getOutput<1> : nullptr
                    ),
                this,
                std::placeholders::_1
                );
            OutputPorts.push_back(pOutFun2);

        }

    virtual ~AlgorithmOutput() {}

protected:

    TLeafType* asLeaf(void)
        {
            return static_cast<TLeafType*>(this);
        }

    TLeafType const* asLeaf(void) const
        {
            return static_cast<TLeafType const*>(this);
        }

public:

    template <int N>
    auto getOutput(int c_Idx) const
        {
            return asLeaf() -> getOutput<N>(c_Idx);
        }

    boost::any getOutputPort(int PortIdx)
        {
            return OutputPorts[PortIdx];
        }

};

class PipeOutputClass: public AlgorithmOutput<PipeOutputClass>
{

public:

    template <int N>
    auto getOutput(int c_Idx) const
        {
            return getOutputImpl<N>::apply(this, c_Idx);
        }

    template<int N, typename S> friend struct getOutputImpl;

    template<int N, typename = void>
    struct getOutputImpl
    {
        static auto apply(
            PipeOutputClass const* p_Self,
            int c_Idx
            )
            { throw std::runtime_error("Wrong template argument."); }
    };

    template <typename S>
    struct getOutputImpl<0, S>
    {
        static std::unique_ptr<double> apply(
            PipeOutputClass const* p_Self,
            int c_Idx
            )
            {
                std::unique_ptr<double> mydouble(new double(10));
                return mydouble;
            }
    };

    template <typename S>
    struct getOutputImpl<1, S>
    {
        static std::unique_ptr<int > apply(
            PipeOutputClass const* p_Self,
            int c_Idx
            )
            {
                std::unique_ptr<int > myint(new int(3));
                return myint;
            }
    };

};

上面示例的问题是我手动定义了成员函数指针pOutFunX,而我想自动执行此过程。

请注意,我不会考虑与上述设计明显不同的设计解决方案。


在此,我提出了一些解决此问题的可能方法的想法。我制定了一个我正在考虑的解决方案计划,如果你试图回答这个问题,这可能会有用:

  1. 获取名为getOutputImpl的用户定义的部分专用结构的数量。
  2. 对于每个此类结构,确定名为apply的成员的输出类型。
  3. 设置(递归)元模板过程,该过程创建指向具有相关签名的函数的指针,并将它们添加到OutputPort向量。
  4. 我认为上面的步骤1-3都必须在编译时完成。如果不需要设计数据输出类的用户的任何干预,我不关心解决方案的美学。但是,我不想使用自定义编译器宏。

    这篇文章展示了如何infer a member function signature,这可能是有用的。

2 个答案:

答案 0 :(得分:2)

我们知道,对于未定义getOutput的每个模板参数,其返回类型为void。因此,我们可以按如下方式确定K

template <int K>
constexpr std::enable_if_t<std::is_void<decltype(getOutput<K>(0))>{}, int> getK() {
    return K-1;
}
template <int K>
constexpr std::enable_if_t<!std::is_void<decltype(getOutput<K>(0))>{}, int> getK() {
    return getK<K+1>();
}

此外,您可以按照以下方式“自动化”push_back

     AlgorithmOutput() : AlgorithmOutput(std::make_index_sequence<getK<0>()>()) {}

private:


     template <std::size_t... indices>
     AlgorithmOutput( std::integer_sequence<indices...> )
     {
         (void)std::initializer_list<int> {
             (OutputPorts.push_back([this] (int i) {return getOutput<indices>(i);}, 0)...
         };
     }

(所有代码未经测试,只是草图!)

答案 1 :(得分:0)

using AO=AlgorithmOutput;
template<size_t N>
using R=decltype(std::declval<AO*>()->getOutput<N>(0));
template<size_t... Is>
std::vector< boost::any > make_vec( std::index_sequence<Is...> ){
  return {
    boost::any(
      std::function< R<Is>(int) >{
        [this](int x){return this->getOutput<N>(x);}
      }
    )...
  };
}

使用C ++ 14类型,但易于编写。传递它std::make_index_sequence<Count>{}它将返回一个向量,其中包含任何包裹lambda的包装函数,这些函数调用apply

你的设计看起来像乱七八糟的静态调度,动态调度,类型擦除和低效的指针语义,但我认为(慈善)这只是一个更复杂的问题的简化,并且设计被证明了。

但是,运行时检查静态参数是否不正确不应该成立。不要在运行时检查编译时错误。

static auto apply( PipeOutputClass const* p_Self, int c_Idx ) { throw std::runtime_error("Wrong template argument."); }

这似乎毫无意义:使其无法编译,无法编译和抛出。