Flow of fun() :

1. You are passing a which is initialized to 0 as the parameter to the fun(). So, You call fun(0) from main().
2. In the call fun(0) the condition n<2 is true since at the start, it is 0. So the function fun(0) will call fun(++n),that is fun(1) and push the current function call on the stack. Notice, the value of n in the function call which is pushed has increased to 1.
3. Again, n<2 evaluates to true since now the value of n is 1. The function will call fun(++n) again, that is fun(2) and push the current function call to stack once again.Notice, the value of n in the function call which is pushed has increased to 2.
4. Now, the value of n is 2 and hence n<2 evaluates to false. So, this time it will not do anything and just terminate
5. Now, the last function call will get popped from stack and cout will get executed. So, the control returns to the function at the top of the stack, which in our case is fun(1). But, here we had increased our n by doing ++n (Check point : 3). So the value printed will be 2. This function call now gets terminated.
6. Now, at the top of stack is the function call that we pushed at first, that is fun(0) but our value of n was increased by ++n (Check point : 2). So now the value of n which is 1 will be printed.

Hope you understand the above explanation and this solves your doubt !

You can think about recursion as nesting the functions inside of each other.

You pass n = 0.

fun(n=0)
{
    if (0 < 2)
    {
        // ++n alters n to be equal to n+1 for our current scope.
        fun(++n); // n = 1 now, fun gets called with n = 1
        {
            fun(n=1)
            {
                if (1 < 2)
                {
                    fun(++n); // n = 2 now, fun gets called with n = 2
                    {
                        fun(2)
                        {
                            if(2 < 2) // returns false
                        } 
                    } // we exit this scope without doing anything futher
                    cout << n << " "; // n = 2 in this scope, here we print the 2
                }
            }
        } // now we exit this scope
        cout << n<<" "; // n = 1 in this scope, here we print the 1
    }
}

Please let me know how I can clarify this further.

This code does not return anything, except for the main function that returns 0 exit code. The function fun just prints.

It prints 2 1, because it computes this:

void fun0()
{
   fun1();
   cout << 1 <<" ";
}

void fun1()
{
   cout << 2 <<" ";
}

Therefore it first prints 2 and then prints 1 after the code returns from fun1.

Every time you make a recursive call a new instance of n will be created. The program will only reach the first cout after two recursive calls, so n will be 2 at that point. I don't want to explain how everything works in detail, I genuinely think that if you write some more printf's you will be able to figure out what the program is doing by yourself. If you figure this out by yourself with my simple hints you'll know how recursion works pretty well.

Firstly function will not return anything until you add a return statement in the function, In your case you are not returning the value, you wrote a statement to print/display the current value of 'n' initially you set a=0 and calling a function "fun(a)" and passing the value of "a" So, in the "fun" function you added a condition which says the value of "n" should be smaller than "2", then you are using the recursive method(a function that calls itself) and pre incrementing "++n" the value of "n" and passing it in the fun function.

n = 0
fun(n)

fun(0){

if (n < 2) *first call true

    {
        fun(++n); *n = 1 before going to next condition it is calling itself*
        cout << 1<<" "; 
    }

}
fun(1){

if (n < 2) *true*

    {
        fun(++n); *n = 2 again before going to next condition it is calling itself*
        cout << 2<<" ";
    }

}
fun(2){

if (n < 2) *flase*

    {
        fun(++n);
        cout << n<<" ";
    }

}

So, it will print 2 and then 1. flow of Recursive function

I hope you get your answer.

fun() is a non tail recursion call and base condition is n<2 then fun will call twice fun(0) &fun(1). As recursion activation record maintain on stack then while reaching at base condition it will print

2 1 Cout "2" Cout "1"

I will recommend please go through recursion concept thoroughly.