pass-by-reference to function vs. to function template

[Robertlzw]

This code does not compile:

void f(const int& val) {...}
int main() {
   f(1);
   return 0;
}

but this is correct (why?):

template <typename T>
void f(const T& val) {...}
int main() {
   f(1);
   return 0;
}

Is there any difference between

template <typename T>
void f(const T& val) {...}

and

template <typename T>
void f(const T val) {...}

? Thanks.

[zwA4jE8b]

1) because when you call f(1) i believe '1' is an r-value and therefor has no address.

if you did something like

int a = 1;
f(a);

that should work because a is an l-value and has an address.

If I am wrong, someone please correct me.


2) the difference is that one is a reference and one is a copy of the parameter.
& will refer to the original address of the parameter being passed so...

template <typename T>
void f(const T& val) 
{
 val = 6;  //val is 'referring' to a, a.k.a. using the same memory address
}

int main()
{
 int a = 5;
 f(a);
 std::cout << a;  //a will now be 6
return 0;
}

however

template <typename T>
void f(const T val) 
{
 val = 6; //val is a copy of a - with a different memory location.
}

int main()
{
 int a = 5;
 f(a);
 std::cout << a;  //a will now 5
return 0;
}

[Robertlzw]

It makes sense. If we explain parameter-passing for function in the same way as for function template, the following code should not compile:

template <typename T>
void f(const T& val) {...}
int main() {
   f(1);
   return 0;
}

because we are passing "1" into it ("1" has no address to refer to). In fact, it not only compiles, but works. I am confused indeed. Why?

[firedraco]

I just compiled

void f(const int& val) {...}
int main() {
   f(1);
   return 0;
}

And it worked fine on VC++ 8 (2008)

[1vRz3TCk]

I don't see a problem with it either (Apple LLVM 2.1, GCC 4.2).

[jsmith]

It is because the compiler is being smart and inlining the function call in the cases where it works.

[zwA4jE8b]

so jsmith, was my first response correct? or am i on the wrong track?

[ne555]

AFAIK it is allowed to bind a constant reference to a temporary.
¿But why inline the function?

[1vRz3TCk]

CreativeMFS wrote:

so jsmith, was my first response correct? or am i on the wrong track?

The initialiser for a reference to a constant object (e.g. const T&) need not be an lvalue and due to type conversion doesn't even need to be the same type.

First any implicit type conversion is carried out, then a temporary is created and used to initialise the reference.

double& dr = 1; // Error: lvalue needed
const double& cdr = 1; // ok 

[zwA4jE8b]

I was doing some reading and came across this

Only the address of the actual original object is put on the stack, not the entire object.

anyway,

so CodeMonkey, i understand case 1, but are you saying in your case 2 that '1' is converted to 'double' and the const forces a temporary to be created? and this temporary has an address?