Re: What's the point of passing parameter by value (vs. const ref)
David Abrahams wrote:
on Thu Jul 03 2008, Marcin.Barczynski-AT-yahoo.com wrote:
On Jul 2, 10:58 am, "Martin T." <0xCDCDC...@gmx.at> wrote:
Not necessarily. For example, try running the program below. With my
compiler it prints the following
default ctor
=== by reference ===
default ctor
copy ctor
swap
dtor
dtor
=== by value ===
default ctor
swap
dtor
=== done ===
dtor
which demonstrates that passing by reference can cause twice as many
copies as passing by value when the source is an rvalue. That can
really add up when the source is expensive to copy like a
vector<string>. If you're going to copy the argument anyway, you're far
better off passing it by value and swapping it into position. That
allows the compiler to elide the copy used to create the parameter value
(inside the function) when the argument (outside the function) is an
rvalue.
------------------------------------------------------------------------
--------------------------------------------------------------------------
Your original code follows. Somehow it's not getting quoted in the
reply. So I put it in by hand.
{ Our apologies. Somehow an article with attachments (even if only pure text)
slipped through both moderation and our posting software. -mod/aps }
#include <utility>
#include <iostream>
struct trace
{
trace() { std::cout << "default ctor\n"; }
trace( trace const& ) { std::cout << "copy ctor\n"; }
trace& operator=( trace const& ) {
std::cout << "copy assign\n"; return *this; }
How is that implemented? Perhaps
trace &operator-(const trace &t) {
std::cout << "assign" << std::endl;
trace temp(t); // one copy ctor
swap(temp); // void trace::swap(trace &); not shown
return *this;
}
~trace() { std::cout << "dtor\n"; }
friend void swap( trace& x, trace& y ) { std::cout << "swap\n"; }
};
template <class T>
struct holder
{
void set_by_value(T x)
{
using std::swap;
swap(x, held);
}
void set_by_reference(T const& x)
{
T tmp(x);
using std::swap;
swap(tmp, held);
}
private:
T held;
};
int main()
{
holder<trace> h;
std::cout << "=== by reference ===\n";
h.set_by_reference( trace() );
std::cout << "=== by value ===\n";
h.set_by_value( trace() );
std::cout << "=== done ===\n";
}
------------------------------------------------------------------------
--------------------------------------------------------------------------
After I run this code with the changes I described, and a few other
minor ones, I get this output:
default ctor
=== by reference ===
default ctor
assign
copy ctor
trace::swap(trace &t)
dtor
dtor
=== by value ===
default ctor
copy ctor
assign
copy ctor
trace::swap(trace &t)
dtor
assign
copy ctor
trace::swap(trace &t)
dtor
dtor
dtor
=== done ===
dtor
Here is the code as I modified it:
#include <utility>
#include <iostream>
#include <string>
void m(const std::string &s) {
std::cout << s << std::endl;
}
struct trace
{
void swap(trace &t) {
m("trace::swap(trace &t)");
}
trace() {m("default ctor"); }
trace(const trace &) { m("copy ctor"); }
trace& operator=(const trace &t) {
m("assign");
trace temp(t);
swap(temp);
return *this;
}
~trace() { m("dtor"); }
};
template <class T>
struct holder
{
void set_by_value(T x)
{
std::swap(x, held);
}
void set_by_reference(const T &x)
{
held = x;
}
private:
T held;
};
void f()
{
holder<trace> h;
m("=== by reference ===");
h.set_by_reference( trace() );
m("=== by value ===");
h.set_by_value( trace() );
m("=== done ===");
}
int main() {
f();
}
Your compiler seems to be doing some nice optimizations for the value
version.
The output from your by value version is,
=== by value ===
default ctor
swap
dtor
=== done ===
I'm a little curious as to what's happening to the instance of trace()
that you're passing to set_by_value.
I wonder what would happen if the code was a little different, maybe,
m("=== by value ===");
const trace t;
h.set_by_value( t );
// do something else with t here
m("=== done ===");
LR
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]