Re: References vs variables - speed impacts?
On 05/11/09 18:47, Rune Allnor wrote:
Hi all.
I always thought references were mere synonym names to already
existing variables;
size_t long_and_complicated_expression;
size_t& i = long_and_complicated_expression;
Instead of typing the long and complicated name, one gets away
with the short and sweet 'i'.
It helps to think of references as that they are mere pointers with
fancy make-up.
In the code I am working with now, references appear to behave
as if they were actual variable assignments.
If you think of references as of pointers, an initialization of a
reference is the same as the initialization of a pointer. The syntactic
difference is that when a reference is initialized it applies &
(address-of operator) to its initializer behind the scenes.
int i;
int* pi = &i; // need to use & to get an address
int& ri = i; // same as above, no need for &
After the reference has been initialized it helps to think that it is a
pointer that gets automatically dereferenced:
*pi = 1; // need to use * to dereference
ri = 1; // same as above, no need for *
size_t sizeof_i = sizeof *pi; // need to use * to dereference
sizeof_i = sizeof ri; // same as above, no need for *
Consider the nested vector indexes
std::vector<size_t> v1;
std::vector<size_t> v2;
size_t n;
{// Unconditional evaluation
const size_t& i = v1[v2[n]];
const size_t& j = v2[v1[n]];
if (someTest(i))
{
// Use j
}
}
{// Lazy evaluation
const size_t& i = v1[v2[n]];
if (someTest(i))
{
size_t& j = v2[v1[n]];
// Use j
}
}
I initially used the reference expressions to save some typing
(the actual names used in the code is quite a bit longer than here),
expecting reference expressions to have no impact on run-time.
However, I saw hints of improved performance when I used the
lazy evaluation code, where the reference j is initialized only if
the test on i succeeds.
In the above code what is causing an observable performance impact must
be the evaluation of v1[v2[n]] and v2[v1[n]], not the initialization of
references i and j.
One way to check this claim is to discard the result of evaluation:
static_cast<void>(v1[v2[n]]);
static_cast<void>(v2[v1[n]]);
--
Max
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]