C++ 在数组（C+；+；）中成对调用函子

我已将数组定义为：

std::array<std::pair<std::shared_ptr<OpCode>, std::shared_ptr<Argument>>, 256> opcodes;

我希望能够做到以下几点：

opcodes[opcode].first(opcodes[opcode].second(opcode));

解释GF文件中的每个操作码。（顺便说一句，键入上面的代码让我觉得我可能想使用自定义类来代替

pair

，这样我就不必重复引用

opcode[opcode]

，但这是为了进一步修订。）

我在CLion中注意到的是，它坚持认为，为了能够调用我的

操作符（）

，它希望我编写如下内容：

int_fast32_t arg = opcodes[opcode].second->operator()(opcode);

所以有两个问题：

有没有其他/更好的方法来管理我的数据结构，这样我就不必像上面那样显式调用

operator（）

我是否应该使用更惯用的结构来管理我的functor（假设它们甚至是工作的正确工具），以便能够单步执行GF字节代码

有没有其他/更好的方法来管理我的数据结构，这样我就不必像上面那样显式地调用operator（）

如果不存储指针，就不需要取消对它们的引用。例如，如果您的函子是flyweights，则不需要在任何地方存储拥有的指针，只需使用

array<pair<std::reference_wrapper<OpCode>, std::reference_wrapper<Argument>>, 256> opcodes;

数组操作码；

是否有一个更惯用的结构我应该用来管理我的函子

如果您总是将它们链接在一起，则可以明确地执行以下操作：

array<std::function<void(int_fast32_t)>, 256> opcodes;

void bind_opcode(int_fast32_t op, OpCode* foo, Argument* bar)
{
  opcodes[op] = [=](int_fast32_t x) { (*foo)((*bar)(x)); }
}

数组操作码；
void bind_操作码（int_fast32_t op，操作码*foo，参数*bar）
{
操作码[op]=[=]（int_fast32_t x）{（*foo）（（*bar）（x））；}
}

（显然，如果您确定对象的生命周期在其他地方得到保证，那么可以使用原始指针、共享指针和引用……或者如果

OpCode

和

参数

对象没有那么大，您可以对函数进行模板化，只需按值复制具体的函子即可）。 }

有没有其他/更好的方法来管理我的数据结构，这样我就不必像上面那样显式地调用operator（）

如果不存储指针，就不需要取消对它们的引用。例如，如果您的函子是flyweights，则不需要在任何地方存储拥有的指针，只需使用

array<pair<std::reference_wrapper<OpCode>, std::reference_wrapper<Argument>>, 256> opcodes;

数组操作码；

是否有一个更惯用的结构我应该用来管理我的函子

如果您总是将它们链接在一起，则可以明确地执行以下操作：

array<std::function<void(int_fast32_t)>, 256> opcodes;

void bind_opcode(int_fast32_t op, OpCode* foo, Argument* bar)
{
  opcodes[op] = [=](int_fast32_t x) { (*foo)((*bar)(x)); }
}

数组操作码；
void bind_操作码（int_fast32_t op，操作码*foo，参数*bar）
{
操作码[op]=[=]（int_fast32_t x）{（*foo）（（*bar）（x））；}
}

（显然，如果您确定对象的生命周期在其他地方得到保证，那么可以使用原始指针、共享指针和引用……或者如果

OpCode

和

参数

对象没有那么大，您可以对函数进行模板化，只需按值复制具体的函子即可）。

---

}

尝试使用

（操作码[opcode].first）（操作码[opcode].second（操作码））？@NathanOliver第一个和第二个是指针，一些
*
缺少Ithink@largest_prime_is_463035818啊哈。没错。最有可能的是
（*opcode[opcode]。第一个）（opcode[opcode]。第二个（opcode））可以。现在我不确定这个问题到底是关于什么的。是不是只有
x->operator（）（…）
vs
（*x）（…）
这件事让你感到不安？请注意，寻求不同/更好的方法是基于边缘观点的。@NathanOliver
second
也是一个指针；）尝试使用
（操作码[opcode].first）（操作码[opcode].second（操作码））？@NathanOliver第一个和第二个是指针，一些
*
缺少Ithink@largest_prime_is_463035818啊哈。没错。最有可能的是
（*opcode[opcode]。第一个）（opcode[opcode]。第二个（opcode））可以。现在我不确定这个问题到底是关于什么的。是不是只有
x->operator（）（…）
vs
（*x）（…）
这件事让你感到不安？请注意，寻求不同/更好的方法是基于边缘观点的。@NathanOliver
second
也是一个指针；）我看得越多，从你的答案中学到的东西就越多。我希望我能不止一次投票支持它。特别是让数组成为
std:：function
中的一个，我可以用它来重构东西。大多数
参数
函子实际上并没有使用它们的参数，而使用它们的函子通常只返回裸操作码（例如，操作码0–63相当于
绘制（操作码）
，我可以用操作码（或操作码减去常量）创建lambda而不是使用函子。因为你的答案，我的代码明显更好。我真的很高兴它起到了作用！我看得越多，从你的答案中学到的东西就越多。我希望我能不止一次地对它进行投票。特别是关于让数组成为一个
std:：function
的想法，我可以用它来重构东西。大多数
Argument
函子实际上不使用参数，而那些使用参数的函子通常只返回裸操作码（例如，操作码0–63相当于
绘制（操作码）
，我可以用操作码（或操作码减去常数）创建lambda而不是使用函子。因为你的回答，我的代码更好。我真的很高兴它有帮助！