Question

我知道我的问题不是一个非常聪明的问题，但我只是想知道你的建议

我想有如下方法

void ClassABC::someMethod(){

    // portion 1
    .
    .
    .
    return ;

   // portion 2 
   .
   .
   .
   .
   return;

   // portion 3
   .
   .
   .
   . 
   return;
}

部分1将在第一次调用someMethod（）时运行。

第二部分将在第二次调用someMethod（）时运行。

第三部分将在第三次调用someMethod（）时运行。

我知道我可以使用全局变量/私有对象的变量来检查要运行的部分，但是也想听听你的意见！，您也可以使用“goto”声明，

谢谢你＆amp;最好的Regrads。 Puwanat S.

Answer 1

void ClassABC::someMethod() {
    static size_t counter = 0;

    switch (counter++) {
        case 0: {
            // 1
            break;
        }
        case 1: {
            // 2
            break;
        }
        default: {
            // 3
            break;
        }
    }
}

请注意，此方法仅适用于static成员函数。

对于非静态成员函数，请使用：

class ClassABC {
public:
    ClassABC();
    void someMethod();
private:
    size_t someMethodCounter;
}

ClassABC::ClassABC() {
    this->someMethodCounter = 0;
}

void ClassABC::someMethod() {
    switch (this->someMethodCounter++) {
    // ...
    }
}

Answer 2

在嵌入式系统中，我们将使用函数指针。它通常比switch语句具有更低的开销，特别是如果一个案例要重复运行。

void ClassABC
{
  void part1() {
    // portion 1 ;
    op_= part2 ;
  }
  void part2() {
    // portion 2
    op_= part3 ;
  void part3() {
    // portion 3
  }

  void someMethod() { op_() ; }

  std::function<void()> op_ = part1 ;
} ;

Answer 3

取决于什么是最有意义的。你也可以这样做

void ClassABC::someMethod1() { ... }
void ClassABC::someMethod2() { ... }
void ClassABC::someMethod3() { ... }

相反，虽然调用者必须稍微了解他们的上下文。

或者，它可以做到

int  ClassABC::someMethodIndex;
void ClassABC::someMethod()
{
    switch (someMethodIndex)
    {
    case 0:   ... // first portion
              someMethodIndex = 1;  // next time do portion 1
              return;
    case 1:   ... // second portion
              someMethodIndex = 2;  // next time do portion 2
              return;
    case 2:   ... // third portion
              someMethodIndex = 0;  // next time do portion 0
              return;
    }
}

Answer 4

如果计算该类的所有对象，则可以使用静态数据成员：http://msdn.microsoft.com/en-us/library/b1b5y48f.aspx

从封装的角度来看，它比全局变量要好得多。

如果你分别计算该类的每个对象，那么只需使用一个存储计数器的常规私有成员变量。

Answer 5

使用计数器变量和switch语句：

switch(counter++) {
case 0:
    // portion 1
    break;
case 1:
    // portion 2
    break;
case 2:
    // portion 3
    break;
...
}

Answer 6

您可以在初始化为零的方法中使用静态变量，并在每次调用时递增，并决定调用代码的相应部分。

使用C ++进行流控制

6 个答案: