有人可以帮我解释一下这个递归函数吗？

Question

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

void reprint(char *a[]) {
    if(*a) {
            printf("%d ",a);
            reprint(a+1);
            printf("%s ",*a);
    }
}

int main() {
    char *coll[] = {"C", "Objective", "like", "don't", "I", NULL};
    reprint(coll);
    printf("\n");
    return EXIT_SUCCESS;
}

As the more experienced will know, this prints the array in reverse. I don't quite understand how!

I need help understanding what reprint(char *a[]) does. I understand pointer arithmetic to a degree, but from inserting printf s here and there, I've determined that the function increments up to the array end, and then back down to the start, only printing on the way down. However, I do not understand how it does this; all I've managed to understand by looking at the actual code is that if *a isn't NULL , then call reprint again, at the next index.

Answer 1

The key to understanding the function's output is that it will print the pointer before recursing, and the actual string after recursing. That's what gives you the impression of going through twice.

Maybe this sounds silly, but follow the program execution manually (or use a debugger). Once it enters the reprint function, it will hit a call to itself after the printf("%d ",a); so it will first "climb" all the way to the NULL. Only then will it encounter the printf("%s ",*a); series.

Modify your program like this, it should help you understand what's going on.

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

static int callcounter = 1;

void reprint(char *a[]) {
    printf ("Entering reprint for the %d time\n",callcounter++);
    if(*a) {
            printf("%p ",a);
            reprint(a+1);
            printf("%s ",*a);
    }
    printf ("Exiting reprint\n");
}

int main() {
    char *coll[] = {"C", "Objective", "like", "don't", "I", NULL};
    reprint(coll);
    printf("\n");
    return EXIT_SUCCESS;
}

Answer 2

Recursive call to a function leaves a pointer to the remaining part of the function on a stack. Yoy may think of it as a list of things to do after the recursive call is complete.

Initially this stack may be considered empty. After a sequence of calls you get a stack that looks like this:

    1st call: reprint ("C", "objective", "like", "don't", "I", NULL);
    2nd call: reprint ("objective", "like", "don't", "I", NULL);printf("C");
    3rd call: reprint ("like", "don't", "I", NULL);printf("objective");
                                                   printf("C"); 
    ...
    6th call: reprint(NULL); printf("I");printf("don't");printf("like");
                             printf("objective");printf("C");

Now the stack unwinds itself and each string is being output in the correct sequence.

Answer 3

Recursion uses the stack. Stacks are a datastructure with LIFO behaviour. reprint will be called 6 times before actually printing the word.

Answer 4

The key to understanding this type of recursion is to know how stacks work.

First: each time reprint() calls itself with (a+1), then a+1 is pushed onto the stack. This means the called reprint() gets a copy of the char** as an argument. The calling reprint's 'a' is not touched. Like you said, this goes on until the passed char ** is NULL, ie the last element in the array. Then the test 'if (*a)' becomes false and reprint will not be called any deeper.

Note at this point, all 5 calls to reprint are 'waiting' for it to return, so none of the printf's after the recursive call to reprint haven't been called yet. Also note that all 5 calls have their own 'a' pointer. This is essential.

Now, since the last call of reprint doesn't call reprint anymore, it will just return. The second to last reprint, the one which has an 'a' pointing to the string "I", can then continue with the next statement after the call to reprint, which is the printf of "I". Once this is done, this function also returns. The third to last reprint, the one with 'a' pointing to the string "don't" can then also continue and prints "don't", etc...

Answer 5

while *a != 0 (NULL) a call to reprint is issued with a+1 which means the next place in the char array, until the last element (NULL) is called, the function just gets back to it's return address which is the line: printf("%s ",*a); and in this frame *a is "I", then the function finishes execution and goes again to its' back to its' return address the same line, in this activation frame *a is "don't" and so on until the return address is the printf("\\n"); line which executes and then finishes main