C# Pow（x，y）功能的工作流程是什么？

我正在学习“sololearn”和UDE课程，试图学习C。我正在做这些挑战，但无法理解下面的代码是如何产生32的（因为在32中是正确的答案，我试图找出原因）。有人能给我解释一下这个过程吗？我想，方法调用本身就把我给甩了

static double Pow(double x, int y)
{
    if (y == 0)
    {
        return 1.0;
    }
    else
    {
        return x * Pow(x, y - 1);
    }
}

static void Main()
{
    Console.Write(Pow(2, 5));
} 

请原谅我的错误编码。我试着在手机上做，这很难，答案是32。有人能解释一下原因吗

---

编辑：下面是我如何处理它的。将2和5传递给Pow，检查是否

y==0

这是错误的，它现在是

y==5

，因此

x*Pow（x，y-1）

公式将被激活。X仍然是2，y现在是4，这意味着它无法再次检查它是否等于0，这个循环继续，直到它返回1.0，X一直保持在2，所以

2*1.0=2，而不是32？
好的，让我们来看看整个过程

首先，静态函数是不需要实例化对象就可以调用的函数。同一类的所有对象共享一个签名。double是C#中的一种类型，它出现在这里是为了显示函数的最终输出类型。Pow是函数的名称，double x，int y是按其类型描述的参数（名称不太清楚，但我们将留待以后使用）

所以x是一个数字，y是这个数字的幂。这里有一个条件来检查两个结果。如果y是0，那么答案总是1，简单的数学。否则，函数将使用递归执行算术（它将再次调用自身，直到满足终止条件）。我们得到32的原因是因为2x2=32。它是2乘以5的幂

我假定您知道main和console.write是什么。
首先要注意的是，这不是通常实现幂函数的方式。这样做是为了演示递归

接下来，让我们看看调用
Pow（2，5）
时会发生什么：

Pow（x=2，y=5）
->返回2*Pow（2，4）
返回2*Pow（2，3）
返回2*Pow（2，2）
返回2*Pow（2，1）
返回2*Pow（2，0）
返回1（因为y==0）
该方法基本上计算“
x
提升到
y
的幂次方”。它以递归的方式执行此操作

首先，它定义了一个基本情况：任何提升到0的幂的值都是1

然后，它定义了在所有其他情况下的操作：
x*Pow（x，y-1）
。假设
y
很大，那么
x*Pow（x，y-1）
是多少？它是
x*x*Pow（x，y-2）
，而它又是
x*x*x*Pow（x，y-3）
。看到这里的图案了吗？最终，您将到达第二个参数，
y-N
，是0，正如我们所确定的，是1。到那时，我们有多少个
x*
？正是
y

让我们看看这一点在
Pow（2,5）
中的作用：

因此，结果32。
对其递归进行问候，并重复直到
y=1
，然后返回
2
，然后在结束时返回
4,8,16,32
2^5=32
能够理解此递归行为日志中的每个操作所有详细信息，以查看实际发生的情况例如：

您可以通过查看这些详细信息来调试代码。
您还可以使用以下链接享受其中的乐趣：
您到底不明白什么？我希望您知道什么是方法，什么是返回值以及静态void main？话虽如此，你还不清楚你有什么困难。你应该重新考虑你问题的标题。标题必须是您遇到的问题的一个小提示。就目前而言，这是一个糟糕的标题。如果你查找“递归”，你可能会得到“见递归”，但也有更多有用的解释。这是一个递归方法。阅读更多关于递归的信息，或者在互联网上搜索“递归”，有很多好的资源。是的，最内部的调用返回1，外部调用返回2。但是，下一个外部调用然后返回x*2，即4，依此类推，直到您有32个。
Pow(x = 2, y = 5)
    -> return 2 * Pow(2, 4)
<- 2 * 16 = 32

  Pow(x = 2, y = 4)
      -> return 2 * Pow(2, 3)
  <- 2 * 8 = 16

    Pow(x = 2, y = 3)
        -> return 2 * Pow(2, 2)
    <- 2 * 4 = 8

      Pow(x = 2, y = 2)
          -> return 2 * Pow(2, 1)
      <- 2 * 2 = 4

        Pow(x = 2, y = 1)
            -> return 2 * Pow(2, 0)
        <- 2 * 1 = 2

          Pow(x = 2, y = 0)
              -> return 1 (because y == 0)
          <- 1

Pow(2, 5)
2 * Pow(2, 4)
2 * 2 * Pow(2, 3)
2 * 2 * 2 * Pow(2, 2)
2 * 2 * 2 * 2 * Pow(2, 1)
2 * 2 * 2 * 2 * 2 * Pow(2, 0)
2 * 2 * 2 * 2 * 2 * 1

using System;
namespace Tester
{
    class test 
    {
        // What Pow actually does:
        static double logPow(double x, int y) {
            var old = x; // Hold the x
            for (var i = 0; i < y; i++){ // do it y times
                x = old * x; // Multiply with it's first self
            }
            return x;
        }
        static int counter = 0;
        static double Pow(double x, int y) {
            counter++;
            Console.Write("Recursive action[" + counter + "] Y status ["+ y +"] : ");
            if (y == 0)
            {
                Console.Write("return 1.0 = " + logPow(x, y) + " \n");
                return 1.0;
            }
            else
            {
                Console.Write("return " + x + " * Pow(" + x + ", " + y + " - 1) = " + logPow(x,y-1) + " \n");
                return x * Pow(x, y - 1);
            }
        }
        static void Main() {
            Console.Write("Last Result : " + Pow(2, 5)); 
        }
    }
}

Recursive action[1] Y status [5] : return 2 * Pow(2, 5 - 1) = 32 
Recursive action[2] Y status [4] : return 2 * Pow(2, 4 - 1) = 16 
Recursive action[3] Y status [3] : return 2 * Pow(2, 3 - 1) = 8 
Recursive action[4] Y status [2] : return 2 * Pow(2, 2 - 1) = 4 
Recursive action[5] Y status [1] : return 2 * Pow(2, 1 - 1) = 2 
Recursive action[6] Y status [0] : return 1.0 = 2 
Last Result : 32