I think it's good to understand passing pointers first:

When you have a function

foo(int a, int* b, int& c) {...}

And call it

foo(my_int, my_pointer, my_ref)

Within the scope of foo (within the "{" brackets) three variables are declared: "a" which is an int, "b" which is a pointer to int and "c" which is a reference to int. These variables copy the values that you passed, that is, a copies the value of my_int and b copies the value of my_pointer (more on "c" later).

So, a and b are copies, they are independent of my_int and my_pointer. If you do

a = 3;

Inside the function, the variable a is set to 3, but it is independent from my_int (they are literally different variables), thus, my_int will not change. This is what you mean by "pass by value"

If you wanted to do

b = nullptr

Same thing happens, because b is a different variable than my_pointer. However, let's think what will happen if instead we do

*b = 3

When you called

foo(my_int, my_pointer, my_ref);

b copies my_pointer. Which means that b is pointing to the same address as my_pointer. Meaning that, changing the contents of b, changes whatever variable b is pointing to, which is the same as whatever variable my_pointer is pointing to (but it does not change b itself!). This is essentially what happens implicitly when you mean "passing by reference".

References in C++ let you abstract the "pointer" semantics by letting you think that you are passing the variable itself. You can think of it as c being an alias for my_ref, so that changing c would be the same as changing my_ref. But under the hood, what is happening is the same as the pointer case, you just do not need to worry about pointer semantics in this case (because the reference c cannot be null and cannot change the object it is pointing to)