C++ 使用C+的流量控制+；

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

我想有如下的方法

void ClassABC::someMethod(){

    // portion 1
    .
    .
    .
    return ;

   // portion 2 
   .
   .
   .
   .
   return;

   // portion 3
   .
   .
   .
   . 
   return;
}

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

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

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

我知道我可以使用全局变量/私有对象的变量来检查要运行的部分，但我也想听听您的意见， 您也可以使用“goto”语句进行申请

谢谢你，再感谢你。

---

普瓦纳特S.

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

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;
    }
}

---

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

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;
    }
}

---

如果计算类的所有对象，则可以使用静态数据成员：

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

---

如果单独计算类的每个对象，则只需使用将存储计数器的常规私有成员变量。

如果计算类的所有对象，则可以使用静态数据成员：

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

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

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

如果您单独计算类的每个对象，那么只需使用一个将存储计数器的常规私有成员变量

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

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

请注意，此方法仅适用于

静态

成员函数

对于非静态成员函数，请使用以下命令：

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

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

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

请注意，此方法仅适用于

静态

成员函数

对于非静态成员函数，请使用以下命令：

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

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

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

---

使用计数器变量和

开关
语句：

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

使用计数器变量和
开关
语句：

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

方法中可以有一个静态变量初始化为零，每次调用时递增，并决定调用代码的适当部分。
方法中可以有一个静态变量初始化为零，并在每次调用时递增，并决定调用代码的适当部分。
在嵌入式系统中，我们将使用函数指针。它通常比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 ;
} ;

void ClassABC
{
无效第1部分（）{
//第一部分；
op=第2部分；
}
无效部分2（）{
//第2部分
op=第3部分；
无效第3部分（）{
//第三部分
}
void someMethod（）{op_u（）；}
std：：功能op_u2;=第1部分；
} ;
在嵌入式系统中，我们会使用函数指针。它通常比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 ;
} ;

void ClassABC
{
无效第1部分（）{
//第一部分；
op=第2部分；
}
无效部分2（）{
//第2部分
op=第3部分；
无效第3部分（）{
//第三部分
}
void someMethod（）{op_u（）；}
std：：功能op_u2;=第1部分；
} ;
“…第一次调用someMethod（）时运行”-第一次用于对象实例，还是第一次用于类？即，您有
类ABC a，c；a.someMethod（）；b.someMethod（）；
-应该
b.someMethod（）；
运行第1或第2部分？@Tony D，对象实例的第一次“…第一次调用someMethod（）时运行”-第一次用于对象实例，还是第一次用于类？即，您是否有
ClassABC a，c；a.someMethod（）；b.someMethod（）；
-是否应
b.someMethod（）；
运行第1部分或第2部分？@Tony D，对象实例的第一次