Question

我有一个不断流式传输的bool值。我需要在bool变为true时触发函数，在bool变为false时触发另一个函数，但每次更改只需触发一次，因此我不能使用{{1}}循环。

c ++中“观察”某个值并在其发生变化时触发的最佳方法是什么？

谢谢。

Answer 1

我会通过设置flagTrue变量和flagFalse变量来解决这个问题。当您遇到第一个True时，flagTrue会从false更改为true，并且将忽略所有后续的True布尔值。同样，当你遇到你的frat False时，flagFalse会从False变为True并忽略所有后面的False booleans。此外，当被检查的布尔值从True变为False时，您将flagTrue更改为False，在其他情况下也是如此。例如：

flagTrue = false
flagFalse = false
if (bool == true && flagTrue == false)
{
   // DoSomething
   flagTrue = true;
   flagFalse = false;
}
else if (bool == false && flagFalse == false)
{
   // DoSomething
   flagTrue = false;
   flagFalse = true;
}

Answer 2

我可能会从这样的事情开始：

#include <functional>
#include <atomic>
#include <iostream>

struct trigger
{
  using closure_type = std::function<void()>;

  trigger(closure_type on_set, closure_type on_reset, bool initial_state = false)
  : _state { initial_state }
  , _on_set(std::move(on_set))
  , _on_reset(std::move(on_reset))
  {}

  void set() {
    if (not _state.exchange(true)) {
      _on_set();
    }
  }

  void reset() {
    if (_state.exchange(false)) {
      _on_reset();
    }
  }

  std::atomic<bool> _state;
  std::function<void()> _on_set;
  std::function<void()> _on_reset;
};

void has_set() {
  // you can marshall accross threads here by posting calls to a 
  // queue
  std::cout << __func__ << std::endl;
}

void has_unset() {
  // you can marshall accross threads here by posting calls to a 
  // queue
  std::cout << __func__ << std::endl;
}

int main()
{
  trigger t { has_set, has_unset };

  t.set();
  t.set();

  t.reset();
  t.reset();

}

Answer 3

看一下观察者模式。您可以将布尔值包装在辅助类中，只要设置了布尔值，就会触发事件。

可观察bool的示例实现：

#include <vector>

class Observer {
public:
    virtual void valueChanged() = 0;
};

class ObservableBool {
private:
    bool value;
    std::vector<Observer*> observers = std::vector<Observer*>();

public:
    bool getValue() {
        return value;
    }

    bool setValue(bool value) {
        bool changed = (value != this->value);
        this->value = value;
        if(changed) raiseEvent();
    }

    void addObserver(Observer* observer) {
        observers.push_back(observer);
    }

    void removeObserver(Observer* observer) {
        observers.erase(std::find(observers.begin, observers.end, observer));
    }

private:
    void raiseEvent() {
        for (int i = 0; i < observers.size; ++i) {
            observers[i]->valueChanged();
        }
    }
};

这可以改进很多。一个非常好的方法是实现从bool到bool的隐式转换（但要小心，对于bool，'='运算符的重载可能是危险的）。您可以将其模板化为支持任意类型而不仅仅是bool，您应该使用智能指针而不是原始指针（std::weak_ptr将是最好的）而不是Observer类，您应该使用函数指针来正确支持lambda。如果你做得对，你可以像普通布尔一样使用类，当设置新值时，开销很小。默认情况下，对更改的所有反应都由更改值的线程执行。

Answer 4

聚会晚了一点，但是如果您只是想把它踢出去（例如进行测试），这是一个稍微简单的解决方案：

/**
 * @brief Set a boolean variable.
 * @param b Pointer to the boolean variable.
 * @param value Set to this value.
 * @return Returns if the value was to be changed.
 */
bool set(bool* b, bool value)
{
    // if b isn't going to change
    if (*b == value) return false;

    // if b is going to change
    else
    {
        *b = value;
        return true;
    }
}

/**
 * @brief A possible implementation
 */
int main()
{
    bool my_variable = false;

    while(true)
    {
        // Set my_variable and flag it if it changed
        bool changed = set(&my_variable, some_function());

        // check for changed
        if (changed)
        {
            // ...
        }
    }
}

这似乎比实现布尔包装器类，触发器和观察者模式要适可而止。

bool改变时的c ++触发函数

4 个答案: