Optimizing a C++ program

Project-specific code or the standard library

A common problem in old C++ code is the use of own, often rather simplistic, code for data containers, such as vectors or strings. There is an excuse for this, as the C++ language and library was standardized as late as in 1997, and compilers lagged quite long after that.

This project had its own string class (used only for a file name construction). I removed the 150 lines of string class and changed the 6 lines that used it to use standard string (actually, a std::ostringstream) instead.

Matrix storage

The main offender, however, was a matrix implemented as an array of arrays of double. The matrix class then had an index operator that simply returned the inner array, used like this:

int x,y;
for(x = 0; x<width; ++x) for(y = 0; y<width; ++y)
  matrix[x][y] *= factor;

This meant that the matrix class gave free access to its inner workings to its users. The first thing to do if I wanted to change anything in the matrix was to create access operators that take two arguments, to replace returning the inner array:

for(int x = 0; x<width; ++x) for(int y = 0; y<width; ++y)
  matrix(x, y) *= factor;

At first I implemented these with a double index just like before, but I soon changed the data to just a std::vector<double>, indexed with (x + width * y). Then, for the methods that just operated on each element (which used a lot of the running time), there was no need to use separate x and y indexes at all, just iterate over all the elements:

for(iterator i = begin(); i != end(); ++i)
  *i *= factor;

By value or by reference

Another common problem is passing parameters by value instead of by reference. Looking at the function declarations, the differece is minimal:

void foo(Arg a);         // By value

void foo(const Arg &a);  // By reference

The ampersand in the later declaration means that that function takes a reference to an Arg, rather than an actual Arg, as argument. If an Arg is a large object, copying it might take quite a while.

Of course, when the method gets a reference to the original object rather than a copy, any change the method makes will be to the original object. To avoid unintended changes, we can declare the argument const. To put lots of “const” in the program also facilitates the mechanical optimization the compiler does for you.

Some classes, notably the std::iostream and family, even makes the copy constructor (and the assignment operator) private, to prohibit copying. Allthough this is to ensure proper semantics rather than as a mere optimization, those two often goes hand in hand.