pass-by-reference for template?

Hello,
>
I learned that when I work with templates in C++, I should have
functions that pass arguments by reference because the type of object
is not known. Does it mean that if I have a function that is template
function, then it's argument should be a reference type, such as the
following?
>
template<class T>
void f(T& t){...}
>
What if I replace the signature by
>
template<class T>
void f(T t){...}
>
or
>
template<class T>
void f(T* tp){...}
>
Would it work and if not, could someone tell me why please?

Hello,
>
I learned that when I work with templates in C++, I should have
functions that pass arguments by reference because the type of object
is not known. Does it mean that if I have a function that is template
function, then it's argument should be a reference type, such as the
following?

template<class T>
void f(T& t){...}
>
What if I replace the signature by
>
template<class T>
void f(T t){...}

template<class T>
void f(T* tp){...}

* Erik Wikström:
>
>
>>>>>>>>
Well. If T is non-const, then
>
T&
>
requires an lvalue actual argument (because an rvalue can't be bound to
a reference).
>
And if T is const, that is, T is mapped to U const, then with the
current standard
>
U const&
>
requires U to have an accessible copy constructor.

Thanks for your replies. The reason I asked the question is that I
was told to use reference rather the actual value because T is a
template parameter and it's value isn't known until instantiation. Is
this not so? or, is there some other kind of template functions that
require the use of reference rather than the actual type?

On Aug 21, 12:40 am, "Alf P. Steinbach" <al...@start.nowrote:>
Do you mean I can use const T& but not T& here? If I have a non-
template function, I can always have both a const-ref version and a
non-const-ref version. Is this not true for template functions?

On 2007-08-22 15:02, Jess wrote:
>
>
>>>>>>>>>>>>>>>>
You can have both const and non-const with templates, the issue has
nothing to do with templates per se, it's just that const ref is the
most flexible way to pass arguments. Consider the following code:
>
class Foo
{
Foo(const Foo&);
Foo& operator=(const Foo&);
int v;
public:
Foo(int i) : v(i) {}
>
};
>
void val(Foo);
>
void ref(Foo&);
>
void cref(const Foo&);
>
int main()
{
Foo f(1);
>
// [1]
val(f);
ref(f);
cref(f);
>
// [2]
ref(Foo(1));
cref(Foo(1));
>
}
>
The class Foo can not be copied (the copy ctor is private), the three
function each use different ways to pass parameters. If you try to
compile the code you'll notice that the call to val(f) under [1] does
not work. This is because passing by value requires that you can copy
the object passed. IF you comment out that call you'll see that both
ref(f) and cref(f) works.
>
Next we'll look at the difference between ref and const ref, to do this
comment out the copy ctor in Foo (this will allow the compiler to
generate one). You'll now notice that ref(Foo(1)) does not compiler but
that cref(Foo(1)) does, this is because a const ref can bind to an
r-value while a normal ref can't.
>
As you can see a const ref is more versatile than a ref, which is more
versatile than passing by value, plus that you don't get the overhead of
copying the object. So if you can using a const ref is usually a good
idea since it will allow usages that ways wont.