c++打卡第五天

嵌套和递归

一、嵌套调用。

  1、嵌套调用是指在一个函数中调用另一个函数，也可以在一个类中使用另一个类作为成员变量。

  2、实例

  ①函数成员调用

#include<iostream>
using namespace std;
int fa2(int a)
{
    return a+1;
}
int fa1(int n)
{
    return 2*fa2(n);
}
int main()
{
    int n;
    cin>>n;
    cout<<fa1(n)<<endl;
    return 0;
}

上述输入n后先调用fa1函数，进入fa1函数后继续调用fa2函数，这就是嵌套调用函数。输入n=2，结果为6。

  ②类成员嵌套使用

class A {
public:
    int val_a;
};

class B {
public:
    A obj_a;

    void set_a_val(int val) { obj_a.val_a = val; }
};

class C {
public:
   B obj_b;

   void set_b_val(int val) { obj_b.set_a_val(val); }
};

int main()
{
    C obj_c;
    obj_c.set_b_val(10);

    cout << "obj_c.obj_b.obj_a.val_a = " << obj_c.obj_b.obj_a.val_a << endl;  // 输出 obj_c.obj_b.obj_a.val_a = 10
}

在上述代码中，类 `B` 中使用了类 `A` 的对象作为成员变量，而类 `C` 又使用了类 `B` 的对象作为成员变量。我们可以通过调用 `obj_c.set_b_val(10)` 方法来设置 `obj_c` 对象中嵌套的类成员的值，并最终输出结果为 `obj_c.obj_b.obj_a.val_a = 10`。

以上就是 C++ 中嵌套调用的两种方式的简单介绍。

二、递归。

    递归指的是在一个函数的定义中调用自身的过程。通常来说，递归可以让我们更简单地描述一些复杂的问题和计算过程。在递归过程中，每次调用会将问题分解成更小的子问题并进行求解，最终得到整个问题的解。递归需要注意结束条件，否则可能会导致无限嵌套调用自身而造成程序崩溃或者死循环。通过以下一个实例来具体说明一下。

1、问题描述。

 编写递归函数getPower计算x的y次方，在同一个程序中针对整形和实型实现两个重载函数：

int getPower(int x,int y);

double getPower(double x,int y);

在主程序中实现输入输出，分别输入一个整数a和一个实数b作为底数，再输入一个整数m作为指数，输出a的m次方和b的m次方。

2、设计思路

    输入待计算的底数x和指数y，进入调用函数，返回底数同时乘以函数（x,y-1)，当y为1或者0时 返回最终值。

3、流程图

 

 4、代码实现

#include<iostream>
using namespace std;
int getPower(int x,int y)
{
    if(y==0)
    {
        return 1;
    }
    if(y>0)
    {
    return x*getPower(x,y-1);
    }
}
double getPower(double x,int y)
{
    if(y==0)
    {
        return 1;
    }
    if(y>0)
    {
    return (1.0)*x*getPower(x,y-1);
    }
}
int main()
{
    int a,k;
    double b;
    cin>>a;
    cin>>b;
    cin>>k;
    int r1;
    double r2;
    r1=getPower(a,k);
    r2=getPower(b,k);
    cout<<r1<<endl;
    cout<<r2<<endl;
    return 0;
}

5、结果实现