C++ – Does passing by reference utilize implicit conversion?

I am trying to get a better understanding of what "passing by reference" really does in c++. In the following code:

#include <iostream>

void func(int& refVar) {
    std::cout << refVar;
}

int main() {
    int val = 3;
    func(val);
}

How does func taking in a reference change the behavior of val when func is called? Is the val variable implicitly converted to a "reference" type and then passed into the function, just like how val would be converted to a float if func took in a float instead of an int? Or is it something else?

Similarly, in this code:

int val = 3;
int& ref = val;

How is a reference of val assigned to ref? Is there implicit type conversion that can be also achieved manually using a function, or does the compiler realize without converting that ref is a reference and that it needs to store the address of val?

>Solution :

Why don’t you just try it?

https://godbolt.org/z/8or3qfd5G

Note that the compiler could do implicit conversion and pass a reference to the temporary.

But the only (good) reason to request a reference is to either store the reference for later use or modify the value. The former would produce a dangling reference and the later would modify a value that will be deleted when the function returns and can never be accessed. So effectively this construct is just bad.

The C++ gods have therefore decided that you aren’t allowed to use this. Implicit conversion produces an rvalue and you can only bind a const reference to an rvalue.

Binding a rvalue to a const reference is still dangerous. You should not store a const reference for later use because it can become dangling.

Update: I noticed I never explained how calling a function taking a reference or assigning to a reference works. It’s basically both the same thing.

A reference just gives something a(nother) name. There is no type change or casting or anything involved. So when you have

`func(val)`

then for the duration of the function the value in val has a second name refVar. Same with int & refVal = val;. There now is a second name for the value in val called refVal.

Afaik they are totally interchangeable.

Note: In a function call how it works is implementation detail but most compilers pass a int * to the function under the hood.