Re: pass-by-reference for template?
On 2007-08-22 15:02, Jess wrote:
On Aug 21, 12:40 am, "Alf P. Steinbach" <al...@start.no> wrote:
* Erik Wikstr?m:
On 2007-08-20 15:52, Jess wrote:
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?
I don't see much connection between templates and using references. In
general, using references is often better than passing by value, whether
you are using templates or not, since it requires less copying.
template<class T>
void f(T& t){...}
What if I replace the signature by
template<class T>
void f(T t){...}
The reference version is slightly better since it does not require the
type used to be copyable. While most types are copyable there are
instances where it might be beneficial to disallow copying.
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.
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?
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.
--
Erik Wikstr?m