C function output

I'm assuming the following is what you want:

#include <stdio.h>

void e(int);

int main()
{
    e(3);
    return 0;
}

void e(int n)
{
    if(n > 0) {
        e(--n);
        printf("%d", n);
        e(--n);
    }
}

This is an example of a recursive function - a function calling itself. Here, at each call the parameter is decremented and the function is again called until the condition n > 0 is not met. Then, the printf("%d", 0) happens. Now the second e(--n) will have no effect until n is at least 2, since the if condition cannot be passed with a value of n less than 1. Further printf()s happen in the reverse order of the call as the function calls are removed from the stack. When the value gets to 2, the second e(--n) gets a chance to make an effect thus printing 0.

You need to learn about recursion (if you still haven't) and then you can get a good picture of how things happen. Also, it will help you if learn more about how the stack is set up when a function is called, and later returned.

The 'flow' goes as follows:

main -> e(3)
e(3) -> IF(3>0)
{
    // n is pre-decremented to 2
    e(2) -> IF(2>0)
    {
        // n is pre-decremented to 1
        e(1) -> IF(1>0)
        {
            // n is pre-decremented to 0
            e(0) -> 0 is not > 0 so this call does nothing.
            // n is still 0 in this function call so...
            printf(0)  <-- The first '0' in the output
            // n is pre-decremented to -1
            e(-1) -> -1 is not > 0) so this call does nothing.
        }
        // n is still 1 in this function call so...
        printf(1)  <-- The '1' in the output
        // n is pre-decremented to 0
        e(0) -> 0 is not > 0 so this call does nothing
    }
    // n is still 2 in this function call so...
    printf(2)  <-- The '2' in the output
    // n is pre-decremented to 1
    e(1) -> (1 is > 0)
    {
        // n is pre-decremented to 0
        e(0) -> 0 is not > 0 so this call does nothing
        // n is still 0 in this function call so...
        printf(0)  <-- The second '0' in the output
        // n is pre-decremented to -1
        e(-1) -> -1 is not > 0 so this call does nothing
    }
}

It helps if you set the code out more clearly:

#include<stdio.h>

main()
{
    e(3);
}

void e(int n)
{
    if(n>0)
    {
        e(--n);    //  First recursion here, but with n=n-1 on entry to the call.
        printf("%d",n);  // outputs (original value of n) - 1.
        e(--n);    // Second recursion here, now with n=n-2 on entry to the call.
    }
}

After denesting the code the reason for the results can be deduced in a single run in a debugger.

e() is recursive and called once before the print and once after. So before you hit your print statement you'll have to go through e again, and again, and again till it finally hits 0.

After that things start unlooping and you'll see prints popping up but it's still a big recursive mess because of the second call to e(n) in which n dips into the negative. I was rather grateful n was signed because if it was unsigned it would loop round to 2^32 and the program would get stuck in, pretty much, an infinite loop.

So yeah, TL;DR: run it through a debugger and learn from the FUBAR a recursion like this can cause.