这段代码是如何工作的，很短的方法来反转一个字符串，它工作，但我不知道如何

Question

请知道这个反向函数是如何工作的，不是很明白，我知道指针确实指向字符串[0]，但是这个函数如何能够打印正确的字符来正确地反转字符串，这是怎么回事是存档吗？

#include <iostream>
using namespace std;

void reverse(char *s); //prototype
//-------------------------------------------------------------------       
int main ()
{
    char str[] = "begin_this is a test_last";    //cstring to be reverse

    reverse(str);    //recursive function

    cout << "\n";

    return 0;
}
//--------------------------------------------------------------------- 
void reverse(char *s)               
{                                   
    if(*s){                         
        reverse(s + 1);
    }else
        return;
    cout << *s;   //question how this print the string in reverse??????
}

Answer 1

您的reverse() 函数实际上并没有反转内存中的字符串，它只是以相反的顺序输出字符串的字符（要实际反转内存中的字符串，请使用 STL 的 std::reverse() 算法）。

现在，让我们看看逻辑。

main() 呼叫reverse()。堆栈帧被压入调用堆栈，其中s 指向第一个字符（str 衰减为指向第一个字符的指针）。

s 没有指向空终止符，所以reverse() 调用自己，在调用堆栈上压入一个新的堆栈帧，其中s 包含指向第二个字符的指针。

s 没有指向空终止符，因此reverse() 再次调用自身，将新的堆栈帧压入调用堆栈，其中s 包含指向第三个字符的指针。

以此类推，直到reverse() 使用堆栈帧运行，其中s 指向空终止符。此时，尚未向std::cout 输出任何内容，并且指向每个字符的指针（包括空终止符）已按从上到下的顺序被压入调用堆栈。

现在，reverse() 停止调用自身并退出，从调用堆栈中弹出当前堆栈帧（s 指向空终止符）。

执行返回到reverse()的前一个调用点，其堆栈帧有s指向最后一个字符。该字符输出到std::cout，然后reverse() 退出，从调用堆栈中弹出该堆栈帧。

执行返回到reverse() 的前一个调用点，其堆栈帧有s 指向倒数第二个字符。该字符输出到std::cout，然后reverse() 退出，从调用堆栈中弹出该堆栈帧。

执行返回到reverse() 的前一个调用点，其堆栈帧有s 指向倒数第三个字符。该字符输出到std::cout，然后reverse() 退出，从调用堆栈中弹出该堆栈帧。

以此类推，直到执行返回main()，整个字符串已经逆序输出到std::cout。

Answer 2

reverse(char *s) 是一个递归函数。只有满足某些条件，递归函数才会终止。在您的示例中，条件为*s == NULL

如果条件不满足，它将使用堆栈来保存当前函数的内容并执行剩余的代码直到它的下一代完成所有任务。

在您的示例中，所有cout << *s 都将被推入堆栈，直到最后一代。因此，第一次执行cout << *s 实际上是打印字符串的最后一个字符。

例如，设char arr[] = "READ" 为数组。

1st   R  // waiting
2nd   E  // waiting
3rd   A  // waiting
4nd   D  // printing!!

上一代完成后：

1st   R  // waiting
2nd   E  // waiting
3rd   A  // printing!!
4nd   D  // finish!!

然后是下一代

1st   R  // waiting
2nd   E  // printing!!
3rd   A  // finish!!
4nd   D  // finish!!

然后是最后一代

1st   R  // printing!!
2nd   E  // finish!!
3rd   A  // finish!!
4nd   D  // finish!!

这正是递归打印字符串的方法。

Answer 3

翻译成英文：为了反向打印一个字符串，你首先反向打印除第一个字符之外的所有内容，然后打印它的第一个字符。如果字符串为空，则什么也不做。

递归，就像一般的函数概念一样，比计算机更古老。您无需了解编程语言的实现方式就可以理解它。
（如果您熟悉数学归纳法，它会有所帮助，但绝对不是必需的。）

其实，如果你理解为了“先做this，再做that”，that必须等到到此 完成了，你就差不多明白了。

唯一缺少的，也是递归的，是为了完成this，你可能需要做一小部分“this，然后那个”首先。

更具体地说，假设我们要反向打印“abc”。

一种看待它的方式是，我们需要先打印'c'，然后是'b'，然后是'a'。

另一种说法是，我们可以先打印“cb”，然后打印“a”。
但是“cb”也是“abc”的“tail”的反转，所以我们应该能够使用相同的过程来反转“abc”和“bc”——只要我们知道如何反转a 较短的字符串，我们可以这样做，然后将字符串的第一个字符添加到后面。
什么时候结束？
当我们到达最短的字符串时，空字符串，我们不需要做任何事情，所以它就结束了。

稍微正式一点，我们可以使用这个过程：

• 如果字符串为空，则什么也不做。
• 如果字符串不为空：
  • 第一次打印，使用此程序，除第一个字符外的所有字符，
  • 然后打印第一个字符。

并且反转“abc”将如下所示：

   Reverse "abc"
-> Reverse "bc", then print 'a'
-> Reverse "c", then print 'b', then print 'a'
-> Reverse "", then print 'c', then print 'b', then print 'a'

Reversing "" is to not do anything. 
After we've done nothing, we can continue executing the rest of the sentence.

-> print 'c', then print 'b', then print 'a'
   [Output: c]
-> print 'b', then print 'a'
   [Output: cb]
-> print 'a'
   [Output: cba]