Recommendations for Efficient C++

Definitions

copy constructor

This is the method MyClass::MyClass(const MyClass &) for some class MyClass, and is used for passing arguments, and for returning results of subroutines, etc.

default constructor

This is the method class::class() for some class, and is called every time a variable of the class is created.

scratch data

This is data in the object which is used as scratch-pad storage for the object's methods, but is not considered part of the object's state.

High Level Improvements

• Look for a better algorithm for important sections of code. This will get far more benefit than any amount of fine-tuning in most cases.
• Use a profiler to discover where you are spending your time, and fine tune (only) that code. Remember Amdahl's law -- if a piece of code is only using 1% of your cpu time, by making it infinitely fast you only gain 1% in performance.

  Fine Tuning Improvements

  • Pass objects to methods by reference. (e.g. f(MyClass &arg)) to avoid unnecessary copies.
  • Don't declare non-trivial objects inside of loops, thereby forcing repeated constructor/destructor calls.
  • Review carefully whether you need to copy pointers to data, or the data to which they point -- copying the pointers is much faster.
  • Make constructors as simple and small as possible.
  • Use constructors rather than assigning when possible; note that

    	MyClass x(5);
    	

    is makes one call to one constructor, while:

    	MyClass x;
    	x = 5;
    	

    calls the default constructor, a type conversion, a copy constructor, and the assignment method in most cases.
  • In line (only)
    • heavily used, (very) small methods (e.g. accessor methods that return a single private data member, or the sum of two data members.)
    • operator methods used in arithmetic expressions where optimization is possible. (e.g. addition of complex numbers).
    Be aware that numerous copies of even medium sized chunks of code are more expensive than subroutine calls due to memory cache hits, paging overhead, etc.
  • save copies of expensive method results when they could be re-requested, but always invalidate these cached copies when appropriate.
  • Define copy constructors where the default action of member-by-member copy does more work than necessary. For example, if you have a chunk of data in an object that holds scratch data, you could avoid copying it on assignments, function calls, etc. by defining a copy constructor.
  • Don't define unnecessary assignment operators (that is, assignment operators that do what the copy constructor would have anyway). Compilers end up calling both the copy constructor and the assignment operator in many instances if both are defined, and calling only the copy constructor if only one is.
  • Don't declare non-trivial temporary objects inside of heavily used methods if you could instead keep a scratch object in the methods class. For example, instead of:

    	class Class1 { 
    	     ...
    	     int f(int x) {
    		 Class2 foobie;
    		 foobie.reset();
    		 foobie.doit(x);
    		 foobie.doit(x);
    		 return foobie.getstuff();
                 }
    	}
    

    move foobie out of Class1::f into Class1:

    	class Class1 { 
    	     Class2 foobie;
    	     ...
    	     int f(int x) {
    		 foobie.reset();
    		 foobie.doit(x);
    		 foobie.doit(x);
    		 return foobie.getstuff();
                 }
    	}
    

    This gets rid of the constructor and destructor call for foobie each time Class1::f is called. This can be a really big savings, especially if Class2 allocates memory, etc.