How does the compiler interpret a template argument (reference vs. non-reference) ?

[mrstephengross]

I'd like to know if there's a standard way that the compiler interprets
a template argument. That is, let's say you pass a Foo instance as a
template argument to some function. Is the instance itself passed, or
does the compiler assume it's a Foo reference? For example:

================================
template<typename I> someFunc(I i) { /* ... */ }

Foo f;

someFunc(f);
=================================

In someFunc(), does I = Foo, or I = Foo&, or I = const Foo & ?

Thanks,
--Steve

 

[mlimber]

I'd like to know if there's a standard way that the compiler interprets
a template argument. That is, let's say you pass a Foo instance as a
template argument to some function. Is the instance itself passed, or
does the compiler assume it's a Foo reference? For example:

================================
template<typename I> someFunc(I i) { /* ... */ }

Foo f;

someFunc(f);
=================================

In someFunc(), does I = Foo, or I = Foo&, or I = const Foo & ?

The first. You can make it the second or third by adding those
parameters to your template, e.g.,

template<typename I> someFunc(I& i) { /* ... */ }

Cheers! --M

 

[mrstephengross]

Can I also explicitly cast the Foo instance in the someFunc()
invocation?

For example: someFunc(const Foo &)f);

--Steve