Re: Call by value vs. Call by reference

From:

=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?= <Erik-wikstrom@telia.com>

Newsgroups:

comp.lang.c++

Date:

Fri, 11 Jul 2008 20:06:41 GMT

Message-ID:

<l3Pdk.852$U5.483@newsb.telia.net>

On 2008-07-11 21:44, Saeed Amrollahi wrote:

On Jul 11, 9:54 pm, "Thomas J. Gritzan" <phygon_antis...@gmx.de>
wrote:

Saeed Amrollahi schrieb:> Dear All

Hi

I have learned when an object is big, I should pass the object using a
reference or pointer to it rather than calling by value.
In the following code, I don't gain cosiderable performance with call-
by-reference vs. call-by-value. Indeed, the perforamnce is absolutely
unconsiderable:

[...]

void f1(std::vector<int> v)

[...]

void f2(std::vector<int> v)

[...]

void f3(std::vector<int>* pv)

[...]

There is no reference. You have two function that do a call-by-value and
one that does a call-by-reference (via pointer).

Obviously, the first two shouldn't show any measurable performance
difference.

--
Thomas

Hi
Sorry for typo and confusion. I actually used reference in the code:
void f1(std::vector<int> v)
void f2(std::vector<int>& v)
void f3(std::vector<int>* pv)

Based on guys' advice, I changed my simple benckmark code to better
one:

template<class T>
void f1(std::vector<T> v)
{
    for (int sz = 0; sz < 1000000; sz++)
        v.push_back(T());
}

template<class T>
void f2(std::vector<T>& v)
{
    for (int sz = 0; sz < 1000000; sz++)
        v.push_back(T());
}

template<class T>
void f3(std::vector<T>* pv)
{
    for (int sz = 0; sz < 1000000; sz++)
        pv->push_back(T());

}

int main()
{

    vector<int> v; // empty vector

    cout << "f1 called" << '\n';
    for (int i = 0; i < 10; i++) {
        vector<int> v;
        f1(v);
    }
    cout << "f1 end" << '\n';
    v.clear();
    cout << "f2 called" << '\n';
    for (int i = 0; i < 10; i++) {
        vector<int> v;
        f2(v);
    }
    cout << "f2 end" << '\n';
    v.clear();
    cout << "f3 called" << '\n';
    for (int i = 0; i < 10; i++) {
        vector<int> v;
        f3(&v);
    }
    cout << "f3 end" << '\n';
        v.clear();

    return 0;
}

I don't use a precise clock, but I expected a difference order of
magnitude efficiency but it is not.
I tested with vector<int>, vector<double> and vector<string>.

Make sure you measure the right thing:

#include <iostream>
#include <vector>

size_t f1(std::vector<int> v)
{
    return v.size();
}

size_t f2(const std::vector<int>& v)
{
    return v.size();
}

size_t f3(std::vector<int>* v)
{
    return v->size();
}

int main()
{

    std::vector<int> v(1000000); // empty vector
    std::cout << "Start" << std::endl;

    for (int i = 0; i < 1000; ++i)
        f1(v);
    std::cout << "f1 done" << std::endl;

    for (int i = 0; i < 1000; ++i)
        f2(v);
    std::cout << "f2 done" << std::endl;

    for (int i = 0; i < 1000; ++i)
        f3(&v);
    std::cout << "f3 done" << std::endl;

    return 0;
}

This shows the overhead of passing a vector with 10^6 elements by value
instead of by pointer/reference. If you want to be sure you can
rearrange the calls so that f1() is called in second or third and see
what takes the longest.

--
Erik Wikstr??m