C++ 如何在多重函数中使用结构

我使用的结构如

  struct IF_ID {
   int PC;
   string instruction;
   };

然后在

    int main()
    {
     IF_ID stage1;
     stage1.PC=0;
     FETCH(stage1);
     DECODE(&stage1);
     return 0;
     }

当我在

FETCH（stage1）

函数中通过

stage1

时，它工作正常，问题是我需要在

FETCH（stage1）

中计算的值再次用于第二个函数

DECODE（stage1）

---

因此，如果

stage1.PC

等于5，例如，我需要在

DECODE（stage1）

函数中重复使用它，我如何才能做到这一点？？？

如果希望

FETCH

更改参数值，它应该接受指向结构的引用或指针作为参数。或者它可以返回一个实例

，如果\u ID

如果您希望

获取

更改参数的值，它应该接受指向您的结构的引用或指针作为参数。或者，如果您通过值将结构传递给FETCH（），它可以返回一个实例

。

这意味着它被复制到函数中

如果希望传递实际结构，则需要该方法来接收其指针或引用：

通过引用：

void FETCH(IF_ID& ref_stage);

指向结构的指针：

void FETCH(IF_ID* ref_stage);

如果通过引用使用，则内部函数语义不会更改。
您正在通过值将结构传递给FETCH（）。

这意味着它被复制到函数中

如果希望传递实际结构，则需要该方法来接收其指针或引用：

通过引用：

void FETCH(IF_ID& ref_stage);

指向结构的指针：

void FETCH(IF_ID* ref_stage);

如果通过引用使用，内部函数语义不会改变。
解决方案是将
stage1
作为对
FETCH（）
函数的引用传递。函数签名应如下所示：

void FETCH(IF_ID& stage);

void FETCH(IF_ID* stage);

或者像这样：

void FETCH(IF_ID& stage);

void FETCH(IF_ID* stage);

在后一种情况下，函数调用还需要在参数前面加一个符号：

FETCH(&stage1);

解决方案是将
stage1
作为
FETCH（）函数的引用传递。函数签名应如下所示：

void FETCH(IF_ID& stage);

void FETCH(IF_ID* stage);

或者像这样：

void FETCH(IF_ID& stage);

void FETCH(IF_ID* stage);

在后一种情况下，函数调用还需要在参数前面加一个符号：

FETCH(&stage1);

不完全确定你想做什么，但让我猜猜

您有一个类型和两个函数（FETCH和DECODE），它们对该类型的输入参数进行操作。第一个函数修改输入参数，您希望修改后的值用作第二个函数的输入

可能您应该将函数声明为（让我们调用您的类型T，因为这可能适用于任何复杂类型或类）

这样，T类型的参数x通过引用传递。在函数主体内执行的修改将影响函数外部的结果

然后可以将第二个函数声明为：

void DECODE(const T &y);

在这里，您再次通过引用传递复杂类型，但这次您承诺不会修改它（const）。
不完全确定您要做什么，但让我猜一下

您有一个类型和两个函数（FETCH和DECODE），它们对该类型的输入参数进行操作。第一个函数修改输入参数，您希望修改后的值用作第二个函数的输入

可能您应该将函数声明为（让我们调用您的类型T，因为这可能适用于任何复杂类型或类）

这样，T类型的参数x通过引用传递。在函数主体内执行的修改将影响函数外部的结果

然后可以将第二个函数声明为：

void DECODE(const T &y);

这里，您通过引用再次传递复杂类型，但这次您承诺不修改它（const）。
 < P> Yochai Timmer和其他一些答案是正确的，但也可以考虑将结构转换成类，并使这些函数成为类的成员，因为它们主要在其上运行。然后代码看起来像：

int main()
{
  IF_ID stage1;
  stage1.PC=0;
  stage1.FETCH();
  stage1.DECODE();
}

但是，如果FETCH除了PC之外不使用if_ID的任何值，并且根据代码的组织方式，让FETCH构造对象可能比传递“空白”对象更为清晰。例如，类似于：

int main()
{
  IF_ID stage1;
  stage1.PC=0;
  stage1.FETCH();
  stage1.DECODE();
}

结构IF\u ID{
int PC；
字符串指令；
如果_ID（）：PC（0）{}//请确保默认值为PC=0
};

IF_ID Fetch（）{
如果第1阶段；
//一定要去拿东西放在第一阶段
return stage1；//如果_ID是一个复制成本很高的大类，
//确保编译器支持“命名返回”
//“价值优化”，即不会产生
//成员变量之间的多余复制
//和返回值。
}

int main（）{
如果_ID stage1=Fetch（）；
解码（第一阶段）；
} 
 < P> Yochai Timmer和其他几个答案是正确的，但也要考虑将结构变成一个类，并使这些函数成为类的成员，因为它们主要在它上面运行。然后代码看起来像：

int main()
{
  IF_ID stage1;
  stage1.PC=0;
  stage1.FETCH();
  stage1.DECODE();
}

但是，如果FETCH除了PC之外不使用if_ID的任何值，并且根据代码的组织方式，让FETCH构造对象可能比传递“空白”对象更为清晰。例如，类似于：

int main()
{
  IF_ID stage1;
  stage1.PC=0;
  stage1.FETCH();
  stage1.DECODE();
}

结构IF\u ID{
int PC；
字符串指令；
如果_ID（）：PC（0）{}//请确保默认值为PC=0
};

IF_ID Fetch（）{
如果第1阶段；
//一定要去拿东西放在第一阶段
return stage1；//如果_ID是一个复制成本很高的大类，
//确保编译器支持“命名返回”
//“价值优化”，即不会产生
//成员变量之间的多余复制
//和返回值。
}

int main（）{
如果_ID stage1=Fetch（）；
解码（第一阶段）；
}
我尝试了你所说的，但是如果你有一个
void FETCH（如果ID&）
版本的函数，你必须调用