使用类来处理非平凡函数序列中的共享状态

Question

我需要按预定顺序对多个设备执行重要的 I/O 操作。

状态（也很重要）需要按顺序维护，如果可以避免，我宁愿不将其作为参数传递给函数：操作a 比操作state.a 更简单.此外，在一个类中封装状态和对该状态的计算似乎是面向对象设计的要点之一。

这将导致类似以下情况（解决方案 1）。

头文件：

/**
 * module.h
 */
void io_sequence();

实现文件：

/**
 * module.cpp
 */

// Helper class, not visible outside this file
class Helper {
public:
  Helper();
  void help() { step1(); step2(); step3(); }
private:
  void step1();
  void step2();
  void step3();

  int a;
  ComplexType b;
  vector<ComplexType2> c;
};

// Implementation of Helper...

// Implementation of the public function
void io_sequence()
{
  // The following two lines could be replaced by Helper().help();
  Helper helper;
  helper.help();
}

这可行，但为什么不使用以下方法（解决方案 2）？

头文件：

/**
 * module.h
 */
void io_sequence();

实现文件：

/**
 * module.cpp
 */

// Helper class, not visible outside this file.
// Invoked like a function.
class help {
public:
  help() { step1(); step2(); step3(); }
private:
  void step1();
  void step2();
  void step3();

  int a;
  ComplexType b;
  vector<ComplexType2> c;
};

// Implementation of help...

// Implementation of the public function
void io_sequence()
{
  (void) help();
}

我会选择解决方案 2，但我在 Internet 上找不到该模式的任何参考。我想这意味着它会被不赞成。

解决方案 2 不好吗？在这种情况下，您建议使用什么方法，还是可以？

请注意，我之前曾问过a similar question for Python，那里接受的解决方案似乎表明 Python 的解决方案 2 很好（根据@jsbueno 的说法是干净的）。

Answer 1

我现在意识到 @user463035818 在他删除的一个 cmets 中对我最初的问题可能意味着类似以下内容（在我的辩护中，评论中没有提到在静态成员函数中创建类的实例） ：

为简洁起见，头文件中的所有内容和简单的代码：

/*
 * Helper.h
 */
class Helper {
public:
    static void help() { Helper h; h.step1(); h.step2(); h.step3(); }
private:
    Helper() {}
    void step1(){}
    void step2(){}
    void step3(){}

    int a;
    int b;
    int c;
};

直接使用，没有抽象类的中间函数：

/*
 * main.cpp
 */
int main()
{
    Helper::help();
}

Answer 2

由于我已经决定将类完全隐藏在函数的实现文件中，现在我想到的一个更明显的解决方案是从类中取出序列逻辑并将其直接放入函数中。我最初反对这一点，原则上（封装），但我现在认为这是有道理的，尤其是将这个想法与使函数成为类的朋友（使函数成为类的朋友将使其访问给所有私人成员，这不是必需的）。

头文件：

/**
 * module.h
 */
void sequence();

实现文件：

/**
 * module.cpp
 */

// Helper class, not visible outside this file
class Helper {
public:
  Helper();
  void step1();
  void step2();
  void step3();

private:
  int a;
  ComplexType b;
  vector<ComplexType2> c;
};

// Implementation of Helper...

// Implementation of the public function
void sequence()
{
  Helper helper;
  helper.step1();
  helper.step2();
  helper.step3();
}