Question regard to this recursion function - c++

Question

A code to find a factorial of an input n:
#include <iostream>
using namespace std;
long long factorial(int num) {
if (num == 0) {
return 1;
}
else {
return num * factorial(num-1);
}
}
int main() {
int num;
cin >> num;
cout << factorial(num) << endl;
}
My questions are:
Here written factorial(num-1) then how can the variable num get decreased per loop ? The function will permanent use num-1 as its argument but num is not saved. I mean there should be num--; in the function. I have tried and printed out variable num at the end of the program and it was the same, num wasnt 0.
Here written if (num == 0) { return 1; } . When num get decreased to 0 then shouldn't the function takes 1 as it final value ? But it doesn't. Just like variable, when you write a = 1 at the end of the program; then doesnt matter what calculation happened to a before, the final value of a will be 1. And as I understand return 1; has the same effect, doesnt it ?
Many thanks

Answer 1

Recursive functions work exactly like non-recursive functions - there is no "loop" and nothing gets decremented.
Perhaps the substitution method could help.
Consider factorial(2).
If we replace num with 2 in the function's body we get
if (2 == 0) {
return 1;
}
else {
return 2 * factorial(2-1);
}
In order to calculate this, we need factorial(1), which becomes
if (1 == 0) {
return 1;
}
else {
return 1 * factorial(1-1);
}
And now we need factorial(0):
if (0 == 0) {
return 1;
}
else {
return 0 * factorial(0-1);
}
This is clearly 1, so now we can move back up and insert the calculated values in place of the function calls.
factorial(1):
if (1 == 0) {
return 1;
}
else {
return 1 * 1;
}
which is 1, and then factorial(2):
if (2 == 0) {
return 1;
}
else {
return 2 * 1;
}
which is 2.
Note that there is no "connection" between the recursive calls - they don't share any variables or other data, their arguments just happen to have the same name - and return does not return to the "topmost" caller but only to the most immediate one, just like other functions.

Answer 2

The original variable "num" is never decreased there.
It's an integer, thus, is a value type. So, everytime by writing factorial(num-1) you create a new variable with the value (num-1) and pass it to the function. (e.g. if num was 5 then it would be like calling factorial(4))
Again, "num" never gets decrased. You just pass a new variable that has the num-1 value. So, in the previous loop when the num was 1, and you called factorial(num-1) you just passed it's like calling factorial(0), and here that 0 was just checked in the if statement and exited by returning 1.

Answer 3

Lets break this down with a concrete example. If you call factorial(5) then what happens is you run if (num == 0), which is false, so you then run return num * factorial(num-1);, where num is 5 so it's return 5 * factorial(4). Now, in order for return to return, it needs to evaluate factorial(4). Just like factorial(5), factorial(4) becomes return 4 * factorial(3), this happens for 3, 2 and 1. Once you are in factorial(1), you get return 1 * factorial(0), and factorial(0) passes if (num == 0), so it is just return 1.
Putting all that together you get
return 5 * 4 * 3 * 2 * 1 * 1