-1

我想找出一个自动逻辑关系检查的解决方案。比如我有一个函数IsGood()，它会从a,b,c....中获取bool值。在主程序中，有if(a||b)or if(b&&c)or if(g&&!k&&l||!z)，不同的关系。我想将它们全部替换为IsGood()，并且我想让这个函数更通用，它可以处理不同的逻辑关系。

所以我的想法是放一些ID，这将有助于这个函数知道现在需要处理哪些变量，例如，得到值k1，k2，k3，但是k1，k2 ， k3之间IsGood()的逻辑关系不知道.||&&IsGood()

所以我想知道如何让IsGood()自动获取值之间的关系。将它们存储在数据库中？

比如：IsGood()首先检查它在place1，所以它查询数据库，结果是：（这为什么我不带参数IsGood()，它会从数据库或配置文件中检索它需要的变量，它需要的只是地点 ID。）

地点 1（地点编号）；k1,k2,k3（变量名）；真，真，假（值）；&&, || （逻辑关系）。

但我不认为这很好......所以，你能给我一些想法吗？非常感谢！我的工作基于 C++。

我想知道一些关于这个的想法：

a||b&&c，我可以存储信息，像0,1，所以0代表||，1代表&&，所以像a&&b||c...这样的结构很容易控制。

但是如何设置（a||b）&&c？我也想找到一种方法来记录这种关系。一个聪明的方法将不胜感激！谢谢。

4

2 回答 2

0

这是行不通的。时期。

在 C++ 中，变量具有作用域。这个名字k1在不同的地方可能意味着不同的东西。因此，即使该函数IsGood神奇地知道它应该以某种方式访问​​一个名为 的变量k1，它仍然无法确定该 k1变量来自哪个范围。

这对 C++ 程序员来说没什么大不了的。他们的解决方案：IsGood(k1)，这意味着：从当前范围调用这个IsGood变量，而不是另一个。 k1

现在，传递运算符有点困难。为此，您需要 lambda IsGood( [&k1,&k2,&k3](){return (k1&&k2)||k3;} );：. 这需要对变量 k1-3 的引用，并将表达式传递(k1&&k2)||k3;给IsGood. 或者分两行：

auto myLambda = [&k1,&k2,&k3](){return (k1&&k2)||k3;} ;
IsGood(myLambda);

同样，这一切都有效，因为您传递IsGood了它需要的信息。它不能以任何其他方式得到它。

于 2012-09-18T12:30:01.377 回答
0

我将首先定义一组对给定对象起作用的逻辑操作，例如：

// This is just a simple wrapper for the first argument
template <typename T>
struct FirstOp
{
  FirstOp(T const& v) : _v(v)
  { }

  T const & operator*() const { return _v; }

  T const& _v;
};

template <typename T>
struct AndOp
{
  AndOp(T const& v) : _v(v)
  { }

  T const & operator*() const { return _v; }

  // Then hack the stream operator
  template <typename O>
  O const & operator>>(O const & o) const
  {
    if (o)
      o = o && _v; // assumes T supports safe bool

    return o;
  }

  T const& _v;
};

template <typename T>
struct OrOp
{
  OrOp(T const& v) : _v(v)
  { }

  T const& operator*() const { return _v; }

  // Then hack the stream operator
  template <typename O>
  O const & operator>>(O const & o) const
  {
    if (!o)
      o = o || _v; // assumes T supports safe bool

    return o;
  }

  T const& _v;
};

template <typename Op1>
struct ResultOf
{
  ResultOf(Op1 const& cOp) : _o1(cOp), _r(*_o1)
  { }

  ResultOf const & operator=(bool r) const
  { _r = r; return *this; }

  operator bool() const { return _r; }

  // Then hack the stream operator
  template <typename O>
  ResultOf& operator>>(O& o)
  {
    o >> *this;
    return *this;
  }

  Op1 const& _o1;
  mutable bool _r;
};

然后定义一个IsGood接受参数，重载支持更多参数。

template <typename T1, typename T2>
bool IsGood(T1 const& t1, T2 const& t2)
{
  return ResultOf<T1>(t1) >> t2;
}

然后你可以调用如下。

int main(void)
{
  std::cout << IsGood(FirstOp<int>(0), OrOp<int>(1)) << std::endl;
}

因此，这种方法允许您将要用于特定逻辑操作的值与该操作一起包装，然后将其传递给通用IsGood函数。现在在这里，实际构造的运算符是硬编码的，但是没有什么可以阻止您从文件中读取它，然后构造适当的运算符以传递给IsGood. 注意：以上是短路的，因此只会在必要时评估参数（将进行函数调用），但不会评估表达式。您应该能够使用上述方法来建立任意复杂的逻辑关系。

免责声明：这是我对你的问题的有限理解......如果它偏离了标记，嗯......

于 2012-09-18T10:38:01.283 回答