谁能解释一下这个程序的递归逻辑？

Question

#include <iostream>

template <int N>  
{
class P 
{

    public:
    static void print() 
    {
         P<N-1>::print();
         std::cout << N << std::endl;
    }
};

template<>
class P<1> {
public:
    static void print() 
    {
        std::cout << 1 << std::endl;
    }
};

int main() {
    const int N = 10;
    P<N>::print();
    return 0;
}

下面代码的输出是：

程序先从10倒数到1，然后一旦N值变为1 P<1>::print 被调用。我不明白在这个电话之后，N 值是如何增加的 by 1 till N=10.can 有人解释这个行为吗？

Answer 1

你能看懂这个程序吗？

void p10_print() {p9_print(); std::cout << 10 << std::endl;}
void p9_print() {p8_print(); std::cout << 9 << std::endl;}
void p8_print() {p7_print(); std::cout << 8 << std::endl;}
void p7_print() {p6_print(); std::cout << 7 << std::endl;}
void p6_print() {p5_print(); std::cout << 6 << std::endl;}
void p5_print() {p4_print(); std::cout << 5 << std::endl;}
void p4_print() {p3_print(); std::cout << 4 << std::endl;}
void p3_print() {p2_print(); std::cout << 3 << std::endl;}
void p2_print() {p1_print(); std::cout << 2 << std::endl;}
void p1_print() {std::cout << 1 << std::endl;}
int main() {
    p10_print();
    return 0;
}

这是同一个程序。模板使编译器为您创建所有这些函数。

如果您仍然无法理解：p2_print() 不会打印 2 直到 after p1_print() returns. p2_print() 调用 p1_print() 打印 1，然后打印 2。p3_print() 调用 p2_print() 打印 1 2，然后打印 3。并且等等。

Answer 2

让我们以 3 为例：

P<3>::print calls P<2>::print
.    P<2>::print calls P<1>::print
.    .    P<1>::print prints 1
.    .    Then returns to P<2>::print
.    Then prints 2
.    Then returns to P<3>::print
Then prints 3
Then returns to main

因为打印是在递归调用之后进行的，所以打印发生在从函数返回时向上堆栈的路径上，而不是在调用函数时向下堆栈。因此，内部的最先打印，外部的最后打印。如果交换这两个语句，则打印顺序相反。

N 上升，因为每个 P<N>::print 返回到 P<N+1>::print。在进去的路上，N 倒下了。

谁能解释一下这个程序的递归逻辑？

Can anyone please Explain the recursion logic of this program?

c++

recursion

templates

output