Question

这是我正在尝试做的简化版本。我想使用指针，但我不知道如何处理范围。顺便说一句，foo（）和bar（）在不同的文件中。 Bar（）得到“calculation_I_am_Not_Interested_In”就好了，但是如何得到bar（）“calculation_I_Want”？

int foo()
{
    int calculation_I_Want = 2 + 2;
    int calculation_I_am_Not_Interested_In = 5 + 5;
    return calculation_I_am_Not_Interested_In;
}

int bar()
{

    int some_Other_Variable_I_Am_Not_Interested_In = foo();

    /*How do I get calculation_I_Want's data from here without using foo's return? 
      Can I use a pointer? if so, how do I deal with scope?*/
}

Answer 1

我建议以不同的方式做这件事。将逻辑拆分为单独的函数并调用所需的部分：

int foo_part1()
{
    int calculation_I_Want = 2 + 2;
    return calculation_I_Want;
}

int foo()
{
    int calculation_I_Want = foo_part1();
    int calculation_I_am_Not_Interested_In = 5 + 5;
    return calculation_I_am_Not_Interested_In;
}

int bar()
{

    int some_Other_Variable_I_Am_Not_Interested_In = foo_part1();

    /*How do I get calculation_I_Want's data from here without using foo's return? 
      Can I use a pointer? if so, how do I deal with scope?*/
}

Answer 2

要在C ++中模拟多个返回值，您可以：

通过非const引用传递参数，在函数体中修改它们

void foo(int& calculation_I_Want, int& calculation_I_am_Not_Interested_In)
{
    calculation_I_Want = 2 + 2;
    calculation_I_am_Not_Interested_In = 5 + 5;
}

通过非const指针传递参数，在函数体中修改它们。不要忘记检查null指针。

void foo(int* calculation_I_Want, int* calculation_I_am_Not_Interested_In)
{
    if(calculation_I_Want)
        calculation_I_Want = 2 + 2;
    if(calculation_I_am_Not_Interested_In)
        calculation_I_am_Not_Interested_In = 5 + 5;
}

您可以返回包含这些变量的新类型对象（struct或class）：

struct CalculationResults
{
    int calculation_I_Want;
    int calculation_I_am_Not_Interested_In;
};

CalculationResults foo()
{
    CalculationResults res;
    res.calculation_I_Want = 2 + 2;
    res.calculation_I_am_Not_Interested_In = 5 + 5;
    return res;
}

您可以返回std::pair，std::tuple

std::pair<int, int> foo()
{
    ....
    return std::make_pair(calculation_I_Want, calculation_I_am_Not_Interested_In);
}

您可以退回容器（std::array，std::vector等。）
你可以停止使用不良代码进行战斗并重构它。大多数情况下，当您在设计代码时出错时，您会面临这些问题。例如，您的函数foo()能够计算两个数字，并且您只对其中一个数字感兴趣。这意味着此处违反了单一责任原则，您必须将foo拆分为两个单独的函数：
```
int foo1()
{
    return 2 + 2;

}

int foo2()
{
    return 5 + 5;
}
```
另一种重构方法是将数据和/或行为分离为单独的类型：
```
class CalculationResults
{
public:
    // TODO: make private
    int calculation_I_Want;
    int calculation_I_am_Not_Interested_In;

    CalculationResults()
    {
        calculation_I_Want = 2 + 2;
        calculation_I_am_Not_Interested_In = 5 + 5;
    }
};
```
这些概念通常用于不可能改变函数参数的语言中（例如，Java）

Answer 3

让我们看一个例子：

void foo(int & result1, int & result2) {
    result1 = 2 + 2;
    result2 = 5 + 5;
}

int main() {
    int r1, r2;

    foo(r1, r2);
    printf("r1: %d\n", r1);
    printf("r2: %d\n", r2);
}

这将输出：

r1: 4
r2: 10

Answer 4

代码看起来像这样：

int foo(int &referenceVar)
{
    referenceVar = 2 + 2;
    int calculation_I_am_Not_Interested_In = 5 + 5;
    return calculation_I_am_Not_Interested_In;
}

void bar()
{

    int outputVar;
    int returnVar = foo(outputVar);
}

在bar（）的末尾，outputVar的值为4，returnVar的值为10.这种传递数据的方法称为＆＃34;传递引用。＆＃34;

Answer 5

您可以使用全局变量，引用或传入指针。 Globals有很多与之相关的固有问题（特别是可扩展性），但只是为了完整：

foo.c的：

int gValueOfInterest
int foo() {
    gValueOfInterest=1;
    ....
}

bar.c：

extern int gValueOfInterest;
bar() {
    int x=gValueOfInterest;
}

另一种方法是使用对变量的引用：

foo.c：

foo(int &value) {
   value=gValueOfInterest;
   ...
}

bar.c：

bar() {
    int x;
    foo(x);
 }

最后，如果您使用的是C而不是C ++，或者您更喜欢使用实际指针，那么您可以这样做：

foo.c：

foo(int *pValue) {
    *pValue=valueOfInterest
}

bar.c：

bar() {
   int x;
   foo(&x);
}

约翰

c ++如何在不使用返回的情况下从函数中获取数据？

5 个答案: