在C / C ++中,我试图在没有if-else梯形图的for循环中调用不同的函数在说明中进行了说明

问题描述

我定义了一些API,例如以下原型。

void foo_network_call_1();
void foo_network_call_2();
void foo_network_call_3();
void foo_network_call_4();

void foo_parse_data_1();
void foo_parse_data_2();
void foo_parse_data_3();
void foo_parse_data_4();

我可以对每种类型的API进行4次调用以完成工作。该代码将不干净等。

我正在寻找一种循环调用上述API的方法,例如for循环。

类似:

for (int i=1; i<5; ++i) {
   foo_network_call_##i();
   foo_parse_data_##i();
}

## 只是表示我在通话中附加了i。我不知道C / C ++中的任何调用机制都可以做到这一点。

谢谢您的帮助。

解决方法

使用函数指针数组似乎很显然。

typedef void (*network_func)();
typedef void (*parse_func)();

network_func network_functions[4] = { foo_network_call_1,... };
parse_func parse_functions[4] = { foo_parse_data_1,... };

for (int i = 0; i < 4; ++i)
{
    (network_functions[i])();
    (parse_functions[i])();
}
,
#include <iostream>
#include <vector>

using namespace std;

int main()
{
    cout << "Hello World!" << endl;

    auto foo_network_call_0 = [](){
        //do something...
    };
    auto foo_network_call_1 = [](){
        //do something...
    };
    auto foo_network_call_2 = [](){
        //do something...
    };
    auto foo_network_call_3 = [](){
        //do something...
    };

    auto foo_parse_data_0 = [](){
        //do something...
    };
    auto foo_parse_data_1 = [](){
        //do something...
    };
    auto foo_parse_data_2 = [](){
        //do something...
    };
    auto foo_parse_data_3 = [](){
        //do something...
    };

    std::vector<void(*)()> ary_call;
    ary_call.push_back( foo_network_call_0 );
    ary_call.push_back( foo_network_call_1 );
    ary_call.push_back( foo_network_call_2 );
    ary_call.push_back( foo_network_call_3 );

    std::vector<void(*)()> ary_data;
    ary_data.push_back( foo_parse_data_0 );
    ary_data.push_back( foo_parse_data_1 );
    ary_data.push_back( foo_parse_data_2 );
    ary_data.push_back( foo_parse_data_3 );

    for ( auto i = 0; i < 4; ++i ) {
        ary_call[i]();
        ary_data[i]();
    }

    return 0;
}
,

如果只是函数的静态列表,请将它们放入一个函数中,然后调用该函数。

赞:

void foo_network() {
  void foo_network_call_1();
  void foo_network_call_2();
  void foo_network_call_3();
  void foo_network_call_4();
}
, 上面的两个答案是正确的 唯一的方法是函数指针 我通常会为我的代码编写此模型

typedef void (*NetworkFunc)(void);
typedef void (*ParseFunc)(void);

const NetworkFunc NetworkFunctions[] = {
    network_func_1,network_func_2,...
};
const NetworkFunctions_Length = sizeof(NetworkFunctions) / sizeof(NetworkFunctions[0]);

const ParseFunc ParseFunctions[] = {
    parse_func_1,parse_func_2,...
};
const ParseFunctions_Length = sizeof(ParseFunctions) / sizeof(ParseFunctions[0]);

现在您可以像这样使用它

for (i =0; i < NetworkFunctions_Length; i++) {
    NetworkFunctions[i]();
}

for (i =0; i < ParseFunctions_Length; i++) {
    ParseFunctions[i]();
}

编辑: 这是替代的c ++示例

#include <iostream>
#include <functional>
using namespace std;

typedef function<void(void)> PrintFunc;

void Print_A(void);
void Print_B(void);
void Print_C(void);

const PrintFunc PrintFunctions[] = {
    Print_A,Print_B,Print_C,};
const int PrintFunctions_Length = sizeof(PrintFunctions) / sizeof(PrintFunctions[0]);

int main(void) {
    for (int i = 0; i < PrintFunctions_Length; i++) {
        PrintFunctions[i]();
    }
}

void Print_A(void) {
    cout << "A\n";
}
void Print_B(void) {
    cout << "B\n";
}
void Print_C(void) {
    cout << "C\n";
}
,

您可以尝试使用函数指针数组,并且每个索引将是一个不同的函数,这样i索引将起作用。

void (*network_call_arr[])() = {foo_network_call_1,foo_network_call_2,foo_network_call_3,foo_network_call_4};

void (*parse_data_arr[]() = {foo_parse_data_1,foo_parse_data_2,foo_parse_data_3,foo_parse_data_4};

,只需从for循环中调用指向指针的索引即可。

for (int i=0; i<4; ++i) 
{
   network_call_arr[i]();
   parse_data_arr[i]();
}
,

您还可以使用一个开关,该开关在优化后可能会编译为跳转表。

for (int i=1; i<5; ++i) 
{  switch( i)
   { case 1:
      foo_network_call_1();
      foo_parse_data_1();
     break;
     case 2:
      foo_network_call_2();
      foo_parse_data_2();
     break;
     // etc
   }
 }
,
body: TabBarView(
         children: [
          Center(child: Text('First screen')),Center(child: Text('Second screen')),]
),