假设要求是这样的: 作为类(class)用户，我想收集有关某个主题的信息，当类(class)有足够的信息时，我希望类(class)将收集的数据列表返回给我。足够的信息被定义为——当所有可能信息的子集的所有信息都被收集时。该子集不是固定的，而是提供给类(class)的。

例如，这是所有可能信息的列表:

{
   string name; 
   int age;
   char sex;
   string location;
}

我想让我的用户有可能告诉我从一些数据源(我的类(class)从中解析数据)收听，直到我得到年龄和性别。

问题是我不知道如何在没有枚举的情况下表达这一点。 基本上我的枚举解决方案是监听数据源，直到我确定在我收集了所有数据的 2 组枚举(收集的，必需的)上使用 std::includes。

没有枚举可以做到吗？

最佳答案

每当我想将一段逻辑的实现与需要它的地方分离时——在这种情况下，“多少数据就足够了”的知识——我会想到回调函数。

大概您的类可以收集的所有可能数据的集合是已知的(name、age、sex & location 在你的例子中)。这意味着您类(class)的所有客户也(可以)知道它，而不会增加耦合和依赖的数量。

我的解决方案是创建一个封装此逻辑的“评估器”类。该类的子类的实例由客户端创建，并在初始请求数据时交给数据收集器；该对象负责决定(并告知“收集器”)何时收集到足够的数据。

#include <string>

// The class that decides when enough data has been collected
// (Provided to class "collector" by its clients)
class evaluator
{
public:
  virtual ~evaluator() {};

  // Notification callbacks; Returning *this aids in chaining
  virtual evaluator& name_collected()     { return *this; }
  virtual evaluator& age_collected()      { return *this; }
  virtual evaluator& sex_collected()      { return *this; }
  virtual evaluator& location_collected() { return *this; }

  // Returns true when sufficient data has been collected
  virtual bool enough() = 0;
};

// The class that collects all the data
class collector
{
public:
  void collect_data( evaluator& e )
  {
    bool enough = false;
    while ( !enough )
    {
      // Listen to data source...

      // When data comes in...
      if ( /* data is name */ )
      {
        name = /* store data */
        enough = e.name_collected().enough();
      }
      else if ( /* data is age */ )
      {
        age = /* store data */
        enough = e.age_collected().enough();
      }
      /* etc. */
    }
  }

  // Data to collect
  std::string name;
  int age;
  char sex;
  std::string location;
};

在您的示例中，您希望特定客户端能够指定 age 和 sex 的组合就足够了。所以你像这样继承evaluator:

class age_and_sex_required : public evaluator
{
public:
  age_and_sex_required()
    : got_age( false )
    , got_sex( false )
  {
  }

  virtual age_and_sex_required& age_collected() override
  {
    got_age = true;
    return *this;
  }

  virtual age_and_sex_required& sex_collected() override
  {
    got_sex = true;
    return *this;
  }

  virtual bool enough() override
  {
    return got_age && got_sex;
  }

private:
  bool got_age;
  bool got_sex;
};

客户端在请求数据时传递这个类的一个实例:

collector c;
c.collect_data( age_and_sex_required() );

collect_data方法在age_and_sex_required实例报告收集的数据量“足够”时退出并返回，而你还没有构建任何逻辑、知识、枚举，无论如何，进入 collector 类。此外，构成“足够”的逻辑是无限可配置的，无需对 collector 类进行进一步更改。

----- 编辑 -----

替代版本将不使用具有..._collected() 方法的类，而只是接受 的单个(typedef'd)函数collector 作为参数并返回 boolean:

#include <functional>
typedef std::function< bool( collector const& ) > evaluator_t;

collector::collect_data(...) 中的代码将简单地调用

enough = e( *this );

每次采集一条数据。

这将消除单独的 evaluator 抽象接口(interface)的必要性，但会增加对 collector 类本身的依赖，因为对象作为 evaluator_t 函数将负责检查 collector 对象的状态以评估是否收集了足够的数据(并且需要 collector 有足够的公共(public)接口(interface)来查询关于它的状态):

bool age_and_sex_required( collector const& c )
{
  // Assuming "age" and "sex" are initialized to -1 and 'X' to indicate "empty"
  // (This could be improved by changing the members of "collector" to use
  // boost::optional<int>, boost::optional<char>, etc.)
  return (c.age >= 0) && (c.sex != 'X');
}

关于c++ - 如何优雅地声明变量集的子集，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21805503/