C 我不明白这个程序做什么，它是一个递归程序 #包括 #包括 #包括 #包括 #定义尺寸10 int whatIsThis（常数int b[]，大小p）； 内部主（空）{ int x； inta[SIZE]={1,2,3,4,5,6,7,8,9,10}； x=这是什么（a，尺寸）； printf（“结果是%d\n”，x）； _睡眠（1000*100）； } int WHATISTHE（常数int b[]，大小p）{ 如果（1==p）{ 返回b[0]； }否则{ 返回b[p-1]+whatistithis（b，p-1）； } }

很抱歉问这个问题，但是我几乎是C编程的初学者，我不能理解这个程序的逻辑，尤其是

returnB[p-1]+whatisshis（b，p-1）。这是什么逻辑？
该函数递归计算数组中元素的总和

第一次调用函数时，p=10。零件

返回b[p-1]+whatIsThis（b，p-1）
将采用
b[9]
并使用
whatIsThis（b，9）
调用函数，该函数将返回

返回b[8]+这是什么（b，8）
。。。一直到

返回b[1]+这是什么（b，1）
它将返回
b[0]
为了理解代码，您必须仔细阅读它。发布的代码呈现得很糟糕，这使得它很难阅读，即使对于精明的程序员来说也是如此。首先，按照我在编辑中所做的方式缩进并隔开程序

函数
whatIsThis（）
首先测试其第二个参数
p
是否具有值
1
，并使用愚蠢的反向语法
（1==p）
，试图检测可能键入错误的
=
运算符：
1=p
将是语法错误，而
p=1
在语法上是正确的，但不是对
p
的测试

第二个参数的名称有误导性，它是
b
中的元素数。因此，将其命名为
n
，
len
，
count
，更具可读性。。。但不是
p
，后者通常用于指针

如果此大小为1，则函数返回数组第一个元素的值

如果不是，它将返回最后一个元素的和以及对同一数组和少一个元素的自身调用的结果

因此，该函数计算数组元素的和

请注意，此函数是假的：它无法处理
p
的
0
值，并调用未定义的行为。更简单、更安全的版本是：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define SIZE 10 

int whatIsThis(const int b[], size_t p);

int main(void) {
    int x;
    int a[SIZE] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    x = whatIsThis(a, SIZE);

    printf("result is %d\n", x);

    _sleep(1000 * 100);
}

int whatIsThis(const int b[], size_t p) {
    if (1 == p) {
        return b[0];
    } else {
        return b[p - 1] + whatIsThis(b, p - 1);
    }
}

或者：

int whatIsThis(const int b[], size_t n) {
    if (n == 0) {
        return 0;
    } else {
        return b[n - 1] + whatIsThis(b, n - 1);
    }
}

当然，对于这样一个简单的任务，递归方法是有风险的，因为它可能会递归到堆栈的深处，并为中等规模的数组调用未定义的行为。编译器不能总是优化递归，特别是当它不是尾部递归时，而这通常不是

这是什么

它是一个行为未定义的函数。：）

当第二个参数等于0时，函数将尝试访问位置
p-1
中的内存，因为类型
size\u t
通常是无符号类型，因此会将其转换为类型
size\u t
的对象中可存储的最大值

此外，由于函数中使用了加法运算，因此两个大数字可能会溢出。因此，函数的返回类型应该是其他更大的整数类型

因此，让我们重写函数，以消除这些缺点。逻辑是一样的

int whatIsThis(const int b[], size_t n) {
    if (n == 0) {
        return 0;
    } else {
        return b[0] + whatIsThis(b + 1, n - 1);
    }
}

或者，如果不使用三元（条件）运算符，函数将如下所示

long long int whatIsThis( const int a[], size_t n ) 
{
    return n == 0 ? 0 : a[n-1] + whatIsThis( a, n - 1 );
}

现在请考虑函数是如何工作的。如果你有这样一个数组

long long int whatIsThis( const int a[], size_t n ) 
{
    if ( n == 0 ) 
    {
        return 0;
    }
    else 
    {
        return a[n-1] + whatIsThis( a, n - 1 );
    }
}

int a[10] = { { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10 };

您可以用以下方式来想象（尽管这段代码不会被编译）

还是像这样

long long int whatIsThis( const int a[], size_t n ) 
{
    if ( n == 0 ) 
    {
        return 0;
    }
    else 
    {
        return a[n-1] + whatIsThis( a, n - 1 );
    }
}

int a[10] = { { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10 };

其中a1[9]是由9个元素组成的数组

int a[10] = { a1[9], 10 };

反过来，阵列a1可以想象为

int a1[9] = { 1, 2, 3, 4, 5, 6, 7, 8, 9  };

int a9[1] = { 1 };

int a[10] = { a1[9], 10 };

a2在哪里

int a1[9] = { a2[8], 9 };

依此类推，我们最终会得到

int a2[8] = { 1, 2, 3, 4, 5, 6, 7, 8  };

a9在哪里

int a8[2] = { a9[1], 2 };

那么这个函数做什么呢

对于数组
a
，它被想象为

int a1[9] = { 1, 2, 3, 4, 5, 6, 7, 8, 9  };

int a9[1] = { 1 };

int a[10] = { a1[9], 10 };

或者

int a[10] = { { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10 };

int a1[9] = { 1, 2, 3, 4, 5, 6, 7, 8 }, 9  };

该函数添加
a1[9]+10

依次为数组
a1
，其设想如下

int a1[9] = { 1, 2, 3, 4, 5, 6, 7, 8, 9  };

int a9[1] = { 1 };

int a[10] = { a1[9], 10 };

或者

int a[10] = { { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10 };

int a1[9] = { 1, 2, 3, 4, 5, 6, 7, 8 }, 9  };

该函数计算
a2[8]+9

如果用
a2[8]+9
替换表达式
a1[9]+10
中的
a1[9]
，那么我们将得到
a2[8]+9+10
，依此类推

因此，该函数计算数组元素的总和。
现在是开始使用调试器的时候了。\n那么，将发生的事情写在纸上怎么样？这当然是教你递归的一种功课，所以：要么运行程序并调试，要么“做调试器”。格式化代码。我想你自己会理解代码的。：）@海莫维茨博士，嗯？什么意思？答案是正确和完整的。它甚至超出了所要求的范围，指出了该功能的缺点并提出了改进建议。“防御不是数组的和”是什么意思？请详细说明，因为如答案所示，它肯定是数组中元素的和。当输入“大小”为3时，返回值是：whatIsThis（数组，2）+数组[2]=数组[1]+数组[1]+数组[2]=1+1+2，所以你错了。@Dr.Haimovitz，恕我直言，在纠正某人之前，请先测试一下。你错了：
whatissis（arr，3）=arr[2]+whatIThis（arr，2）=arr[2]+arr[1]+whatissis（arr，1）=arr[2]+arr[1]+arr[0]=3+2+1=6
对不起，我的错我以为停车条件是p等于0对不起<代码>f（{1,2,3}，3）=3+f（{1,2,3}，2）=3+2+f（{1,2,3}，1）=3+2+1=