Creation of temporary objects in loop

[Jim Langston]

Which is more efficient (if either)

[Pseudo code]
MyHugeClass MyObject;
for ( int i = 0; i < 1000; ++i )
{
MyObject = SomeVal[i];
Use MyObject;
}

or

for ( int i = 0; i < 1000; ++i )
{
MyHugeClass MyObject = SomeVal[i];
Use MyObject;
}

That is, if I declare MyObject inside a for loop, does it get recreated
each iteration, or does the compiler create it once and reuse each time?

Or is it UB?

[Alf P. Steinbach]

* Jim Langston:

Which is more efficient (if either)

[Pseudo code]
MyHugeClass MyObject;
for ( int i = 0; i < 1000; ++i )
{
MyObject = SomeVal[i];
Use MyObject;
}

or

for ( int i = 0; i < 1000; ++i )
{
MyHugeClass MyObject = SomeVal[i];
Use MyObject;
}

In terms of execution time: depends on the object, so if it turns out
to be critical, measure.

In terms of programmer time: the first is often hugely more efficient.

In general: it's not a good idea to worry about execution efficiency in
cases where you suspect the compiler might be able to do something.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[ben]

"Jim Langston" <ta*******@rock etmail.com> wrote in message
news:wS******** *********@fe05. lga...

Which is more efficient (if either)

[Pseudo code]
MyHugeClass MyObject;
for ( int i = 0; i < 1000; ++i )
{
MyObject = SomeVal[i];
Use MyObject;
}

or

for ( int i = 0; i < 1000; ++i )
{
MyHugeClass MyObject = SomeVal[i];
Use MyObject;
}
It depends. But in most cases the first case will be more efficient because
the assignment is usually lighter than a copy constructor. But also consider
ausing reference:

for (int = 0; i < 1000; ++i)
{
MyHugeClass& MyObject = SomeVal[i];
Use MyObject;
}

That is, if I declare MyObject inside a for loop, does it get recreated
each iteration, or does the compiler create it once and reuse each time?
yes, it is not only recreated but also destroyed each iteration.

Or is it UB?

[Alf P. Steinbach]

* Alf P. Steinbach:

* Jim Langston:

Which is more efficient (if either)

[Pseudo code]
MyHugeClass MyObject;
for ( int i = 0; i < 1000; ++i )
{
MyObject = SomeVal[i];
Use MyObject;
}

or

for ( int i = 0; i < 1000; ++i )
{
MyHugeClass MyObject = SomeVal[i];
Use MyObject;
}
In terms of execution time: depends on the object, so if it turns out
to be critical, measure.

In terms of programmer time: the first is often hugely more efficient.

I meant the _second_, of course.

"Resetting" an object is often difficult and makes it difficult to rely
on anything about the object state.

An exception is where an object has a natural default state such as an
empty string or empty vector, but even there the cost of construction
+ destruction, relative to assignment/reset, is typically negligible.

In general: it's not a good idea to worry about execution efficiency in
cases where you suspect the compiler might be able to do something.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[E. Robert Tisdale]

Jim Langston wrote:

Which is more efficient (if either) [Pseudo code]

for (int i = 0; i < 1000; ++i) {
MyHugeClass MyObject = SomeVal[i];
// Use MyObject;
}

or

MyHugeClass MyObject;
for (int i = 0; i < 1000; ++i) {
MyObject = SomeVal[i];
// Use MyObject;
}

That is, if I declare MyObject inside a for loop,
does it get recreated each iteration?
Or does the compiler create it once and reuse each time?
Or is it UB?

The first form is always preferred over the second above
because it confines MyObject to the narrowest scope.

The assignment operator is often more expensive
than the copy constructor/destructor combination.

A good optimizing C++ compiler will automatically
"boost" the storage allocation for MyObject up out of the loop and,
if the copy constructor and destructor can be inline'd,
it will optimize away unnecessary overhead.

Avoid premature optimization.
Use your profiler to locate performance bottlenecks.
Don't even consider the second option
unless you can demonstrate that the first is causing problems.

[Sammy]

al***@start.no (Alf P. Steinbach) wrote in news:42b61b7c.1 32200562
@news.individua l.net:

A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

I have to remember this one

[rob2005]

The second will be much more efficient since the compiler can optimize
that code quite a lot.

MyObject o = getObject ();

Here the temporary can be taken as 'o' so this is often even more
efficient that to get the objetct by reference.

regards

Rob

[ben]

You had the first and second code snippet swapped!

ben

[Rene Moehring]

On Mon, 20 Jun 2005 11:30:27 +1000, ben wrote:

"Jim Langston" <ta*******@rock etmail.com> wrote in message
news:wS******** *********@fe05. lga...

Which is more efficient (if either)

[Pseudo code]
MyHugeClass MyObject;
for ( int i = 0; i < 1000; ++i )
{
MyObject = SomeVal[i];
Use MyObject;
}

or

for ( int i = 0; i < 1000; ++i )
{
MyHugeClass MyObject = SomeVal[i];
Use MyObject;
}
It depends. But in most cases the first case will be more efficient because
the assignment is usually lighter than a copy constructor.

Besides the fact that no copy ctor is used. How can assigning be cheaper
than a copy? The assignment in the first case is a copy.
But also consider
ausing reference:

for (int = 0; i < 1000; ++i)
{
MyHugeClass& MyObject = SomeVal[i];
Use MyObject;
}

That is, if I declare MyObject inside a for loop, does it get recreated
each iteration, or does the compiler create it once and reuse each time?

yes, it is not only recreated but also destroyed each iteration.

Or is it UB?

--
I'm not a racist. I hate everyone equally!

[msalters]

E. Robert Tisdale schreef:

Jim Langston wrote:

for (int i = 0; i < 1000; ++i) {
MyHugeClass MyObject = SomeVal[i];
// Use MyObject;
}

A good optimizing C++ compiler will automatically
"boost" the storage allocation for MyObject up out of the loop and,
if the copy constructor and destructor can be inline'd,
it will optimize away unnecessary overhead.

The common term is to "hoist" the allocation. However, often all
allocations are done at once when the function is called. Allocating
storage is simply a matter of incrementing the stack pointer and
using that stackframe. It's trivial to see that __sp+=4;__sp+=4 ; can
be optimized to __sp+=8;. Hence, the term "hoisting" is more commonly
applied to "hoisting" the evaluation of constant expression, i.e.

int offset = foo();
for (int i = 0; i < 1000; ++i) {
MyHugeClass MyObject = SomeVal[2* offset + i];
}
Here, (2*offset) can be hoisted.

HTH,
Michiel Salters