Question

在使用C ++ 11时，我遇到了一个几乎合乎逻辑的问题。

我有一个我必须绘制的课程（也就是画一个趋势），我想排除所有不满足给定条件的点。这些点属于类Foo，所有条件函数都使用签名bool Foo::Bar(Args...) const定义，其中Args...表示多个参数（例如返回值的上限和下限）。 / p>

一切顺利，直到我希望将一个条件应用于绘制的值。假设我有一个FooPlotter类，其类似于：

template<class ...Args> GraphClass FooPlotter::Plot([...],bool (Foo::*Bar)(Args...), Args... args)

将迭代我的数据容器并将条件Foo::*Bar应用于所有元素，绘制满足给定条件的值。

到目前为止一切顺利。

在给定的点上，我想将一个条件向量传递给同一个方法，以便使用几个条件来过滤数据。

我首先创建了一个类来包含我以后需要的所有内容：

    template<class ...Args> class FooCondition{
        public:
            FooCondition(bool (Foo::*Bar)(Args...) const, Args... args)
            {
                fCondition = Bar;
                fArgs = std::make_tuple(args);
            }
            bool operator()(Foo data){ return (data.*fCondition)(args); }
        private:
            bool (Foo::*fCondition)(Args...) const;
            std::tuple<Args...> fArgs;
    };

然后我陷入困境，如何定义一个（可迭代的）容器，它可以包含FooCondition个对象，尽管它们有Args...个参数包的几种类型。问题是某些方法有Args... = uint64_t,uint_64_t而有些方法不需要调用参数。

我在如何处理这种情况上挖掘了一下。我尝试了几种方法，但没有一种方法效果很好。

目前我添加了忽略所有Bar方法的参数，统一了它们并解决了这个问题，但我并不满意！

您是否了解如何以优雅的方式存储不同类型的FooCondition对象？

编辑：有关我想要获得的结果的其他信息。

首先，我希望能够创建std::vector个FooCondition个项目：

    std::vector<FooCondition> conditions;
    conditions.emplace_back(FooCondition(&Foo::IsBefore, uint64_t timestamp1));
    conditions.emplace_back(FooCondition(&Foo::IsAttributeBetween, double a, double b));
    conditions.emplace_back(FooCondition(&Foo::IsOk));

此时我希望我可以在FooPlotter::Plot方法中执行以下操作：

    GraphClass FooPlotter::Plot(vector<Foo> data, vector<FooCondition> conditions){
        GraphClass graph;
        for(const auto &itData : data){
            bool shouldPlot = true;
            for(const auto &itCondition : conditions){
                shouldPlot &= itCondition(itData);
            }
            if(shouldPlot) graph.AddPoint(itData);
        }
        return graph;
    }

你可以说FooCondition struct应该使用重载运算符自动将正确的参数传递给方法。

这里的问题是找到正确的容器，以便能够创建FooCondition模板的集合，尽管它们的参数包大小。

Answer 1

在我看来，FooCondition您尝试使用std::function<bool(Foo *)>初始化的std::function<bool(Foo const *)>（或者std::bind）创建替代品修复Foo方法的一些参数。

我的意思是......我认为不是

std::vector<FooCondition> conditions;
conditions.emplace_back(FooCondition(&Foo::IsBefore, uint64_t timestamp1));
conditions.emplace_back(FooCondition(&Foo::IsAttributeBetween, double a, double b));
conditions.emplace_back(FooCondition(&Foo::IsOk));

你应该写一些东西

std::vector<std::function<bool(Foo const *)>> vfc;

using namespace std::placeholders;

vfc.emplace_back(std::bind(&Foo::IsBefore, _1, 64U));
vfc.emplace_back(std::bind(&Foo::IsAttributeBetween, _1, 10.0, 100.0));
vfc.emplace_back(std::bind(&Foo::IsOk, _1));

以下是一个简化的完整工作C ++ 11示例，其main()模拟Plot()

#include <vector>
#include <iostream>
#include <functional>

struct Foo
 {
   double  value;

   bool IsBefore (std::uint64_t ts) const
    { std::cout << "- IsBefore(" << ts << ')' << std::endl; 
      return value < ts; }

   bool IsAttributeBetween (double a, double b) const
    { std::cout << "- IsAttrributeBetwen(" << a << ", " << b << ')'
         << std::endl; return (a < value) && (value < b); }

   bool IsOk () const
    { std::cout << "- IsOk" << std::endl; return value != 0.0; }
 };

int main ()
 {
   std::vector<std::function<bool(Foo const *)>> vfc;

   using namespace std::placeholders;

   vfc.emplace_back(std::bind(&Foo::IsBefore, _1, 64U));
   vfc.emplace_back(std::bind(&Foo::IsAttributeBetween, _1, 10.0, 100.0));
   vfc.emplace_back(std::bind(&Foo::IsOk, _1));

   std::vector<Foo> vf { Foo{0.0}, Foo{10.0}, Foo{20.0}, Foo{80.0} };

   for ( auto const & f : vf )
    {
      bool  bval { true };

      for ( auto const & c : vfc )
         bval &= c(&f);

      std::cout << "---- for " << f.value << ": " << bval << std::endl;
    }
 }

另一种方法是避免使用std::bind并改为使用lambda函数。

以示例

std::vector<std::function<bool(Foo const *)>> vfc;

vfc.emplace_back([](Foo const * fp)
                 { return fp->IsBefore(64U); });
vfc.emplace_back([](Foo const * fp)
                 { return fp->IsAttributeBetween(10.0, 100.0); });
vfc.emplace_back([](Foo const * fp)
                 { return fp->IsOk(); });

Answer 2

除了所有的foo栏之外，你只需要一个可以实现的方法来满足情节。

只需在接受节点的类上添加Plot方法，然后在同一步骤中执行转换和绘图。

绘图时你不必担心args，因为每个函数都知道它需要什么参数。

因此，一个简单的args *就足够了，当null没有参数时，其中每个arg都会显示它的类型和值，或者可以从函数调用中假设。

变量参数和函数指针vector

2 个答案: