General C++ Performance Improvement Tips [closed]

Answer 1

A number of the tips in Effective C++, More Effective C++, Effective STL and C++ Coding Standards are along this line.

A simple example of such a tip: use preincrement (++i) rather than postincrement (i++) when possible. This is especially important with iterators, as postincrement involves copying the iterator. You optimizer may be able to undo this, but it isn't any extra work to write preincrement instead, so why take the risk?

Answer 2

Why nobody mentioned it so far? Why is everyone into poor little ++i?

One of the best little things you can easily do, to not pessimize your code:

Effective C++ by Scott Meyers, Item 20:

Prefer pass-by-reference-to-const to pass-by value

Example:

// this is a better option
void some_function(const std::string &str);
// than this:
void some_function(std::string str);

In case of short std::string you might not win much, but passing big objects like that, can save you quite a lot of computing power as you avoid redundant copying. And can also save you from a bug or two if you forgot to implement your copy constructor.

Answer 3

The best way to improve these skills is reading books and articles, but I can help you with some tips:

• 1- Accept Objects by reference and Primitive or Pointer Types by value but use object pointer if a function stores a reference or a pointer to the object.
• 2- Don't use MACROS to declare constants -> use static const.
• 3- Always implement a virtual destructor if your class may be subclassed.

Answer 4

• Avoid multiple inheritance.
• Use virtuals when they are necessary, not just for fun
• Use templated collection classes only when it's a pain not to

Answer 5

If I understand you correctly, you're asking about avoiding Premature Pessimization, a good complement to avoiding Premature Optimization. The #1 thing to avoid, based on my experience, is to not copy large objects whenever possible. This includes:

• pass objects by (const) reference to functions
• return objects by (const) reference whenever practical
• make sure you declare a reference variable when you need it

This last bullet requires some explanation. I can't tell you how many times I've seen this:

class Foo
{
    const BigObject & bar();
};

// ... somewhere in code ...
BigObject obj = foo.bar();  // OOPS!  This creates a copy!

The right way is:

const BigOject &obj = foo.bar();  // does not create a copy

These guidelines apply to anything larger than a smart pointer or a built-in type. Also, I highly recommend investing time learning to profile your code. A good profiling tool will help catch wasteful operations.

Answer 6

One of the good starting points is the Sutter's Guru of the week series, and the Exceptional C++ books that grew out of that.