Question

我的程序中有多个功能。每个功能都有一些条件。如果满足条件，则它将值传递给另一个函数，该函数再次使用某些条件检查值，修改它。

第一个函数[名为'squarefree（）']从main [显然]调用，它继续调用另一个函数，该函数当然调用另一个函数，直到该过程在最后一个名为'end（）'的函数停止。像这样：

#include <iostream>
using namespace std;

int squarefree(int n);
int goodnumber(int sf);
int end(int gn);

int main() {
    // your code goes here
    int l,r;
    cin>>l;
    cin>>r;
    for(int p=l;p<=r;p++)
    {squarefree(p);}
    /*int ret=end(int gn); PROBLEM LIES HERE
    cout<<ret; */
    return 0;
}


int squarefree(int n){
    int i;
    for(int i=2;i<n;i++)
    {
        if((n%(i*i))==0)
        {
            cout<<"number not square free"<<endl;
            break;
        }
        else{
            cout<<"number square free"<<endl;
            goodnumber(n);
            break;

        }
    }
    return 0;
}


int goodnumber(int sf){
    cout<<"Sf is:"<<sf<<endl;
    int s=0,c=0,flag=0;
    for(int j=1;j<=sf;j++)
    {
        if(sf%j==0)
        {
            s+=j;
            for(int k=2;k<=j/2;++k)
            {
                if(j%k==0)
                {
                 c++;


                }
            }
        }
    }
    cout<<"s is:"<<s<<endl;
    cout<<"no.of prime numbers dividin s are:"<<c<<endl;
    for(int l=2;l<=c/2;++l)
    {
      if(c%l==0)
       {
          flag=1;
          break;
        }
    }
    if (flag==0)
      {cout << "C is a prime number, so this is good number and needs to be passed to next function"<<endl;
       end(s);

      }
    else
      {cout << "C is not a prime number"<<endl;

      }
      return 0;
}


int end(int gn)
{
    int sum=0;
    sum+=gn;
    cout<<"SUm of factors of the good number is:"<<sum<<endl;
    return sum;
}

'end（）'函数返回一个值sum。现在我希望每次main（）函数中的for循环运行时都会更新此值sum。例如：第一次迭代中的求和是5，求和是第二次迭代是10，所以总和得到15，依此类推。

如果以某种方式，end函数返回的值可以被提取到main函数中，这将是很好的。

Answer 1

查看所有那些int - 返回始终返回0的函数。您可以利用它。

一个简单的例子：

#include <iostream>

int step3(int val)
{
    return val * val;
}

int step2(int val)
{
    return step3(val + 1);
}

int step1(int val)
{
    return step2(val * 2);
}

int main()
{
    std::cout << step1(1);
}

但要小心。您可能会发现一个案例，即您没有获得任何有效结果，并且需要通知调用者没有找到结果。

Answer 2

除了让函数返回管道中下一个阶段的结果的想法之外，这是一个很好的想法，你可以传递存储结果的变量的地址（允许你返回超过一个结果，或错误代码），或将每个阶段的结果存储在临时变量中并返回（允许您在多个计算中使用结果）。我建议不要使用全局变量来绕过堆栈;这被认为是不好的做法。

一些例子：

// Returning the result of the next stage in the pipeline:
int g(int);

int f(int x)
{
  return g(x);
}

// Passing a variable by reference:
enum errcode { success, failure };

errcode sqr( int input, int& output )
{
  output = input * input; // This modifies the second variable the caller gave.
  return success;
}

// Storing in a temporary variable:
int stage2(int);

int stage1(int x)
{
   const int y = stage2(x);    // Store the result in a temporary.
   const int z = sqr(y);
   return z;
}

// Passing results through a global variable is a bad idea:
int necessary_evil = 0;  // Declared in global scope; should at least be
  // declared static if possible to make it visible only in this source file.
  // Namespaces are a fancier way to do something similar.

void kludge(int x)
{
   necessary_evil = x * x;   // The caller will check the global.
   return;
}

标准库中有所有这些示例：printf()本质上是vfprintf()的包装器，strtol()通过引用获取一个参数，该函数设置为指向字符串的其余部分，errno是一个全局变量。

如何在不直接调用函数

2 个答案:

一些例子：