有多少种生成临时对象/不必要调用构造函数的方法？

Question

Temporary objects/wasteful objects can be a big bottleneck for ultra-low latency applications. I am trying to make myself aware of the pitfalls of needlessly invoking a constructor, so I wanted to know if there are any ways I am unware of. I am aware of the following ways when the constructor is "silently" called:

1)

//a temporary "object" is created when adding x and y and then assigned to z
int x,y,z;
z = x + y;    

2)

//A temporary object is created here when the return value is passed. Its also possible
//another temporary object is created during the assignment?
A a = my_function();

A my_function(){
    return new A();
}

3)

A a = my_function();

A my_function(){
    A a;
    return a;
}

4) Where arguments are passed in by value

A a;
my_function(a);

void my_function(A a){

}

5) Not using initialiser lists:

class A{
   B b;
   C c;

   A(B bb, C cc):
   {
       this.b = bb;
       this.c = cc;
   }

}

Are there any other examples where constructors are implicitly called?

Answer 1

A a = A(); (a simpler case of your function example), though I believe most compilers these days optimize that to direct initialization. (GCC has an option to disable that optimization, though.)

By the way, you might want to take a look at http://en.wikipedia.org/wiki/Copy_constructor .

Answer 2

In c++11 , rvalue references and move semantics can solve several types of unnecessary copies of temporaries, which occur in situations such as returning and passing arguments by value. So some of the don'ts you listed no longer apply in the new standard.

Answer 3

IMO you're going backwards. Especially taking into account that in optimized build majority of your cases will have all temporaries completely removed.

The suggested way is to write a correct program in a style that is easy to review. Then if you are not happy with performance, drop profiler at it, and fix the small portion that takes up most of time. Practice shows it is quite rarely where programmers think it will be.

The one thing to avoid from your list is params by value for class types with unpredicted size. Most time const& is okay.

Avoiding assigments and sticking to initialization is a good guideline too, but not for performance reasons. Certainly it often does not apply for some types like collections.