Question

I’m doing a computation in C++ and it has to be as fast as possible (it is executed 60 times per second with possibly large data). During the computation, a certain set of items have to be processed. However, in different cases, different implementations of the item storage are optimal, so i need to use an abstract class for that.

My question is, what is the most common and most efficient way to do an action with each of the items in C++? (I don’t need to change the structure of the container during that.) I have thought of two possible solutions:

1. Make iterators for the storage classes. (They’re also mine, so i can add it.) This is common in Java, but doesn’t seem very ‘C’ to me:

   class Iterator {
   public:
       bool more() const;
       Item * next();
   }
   

2. Add sort of an abstract handler, which would be overriden in the computation part and would include the code to be called on each item:

   class Handler {
   public:
       virtual void process(Item &item) = 0;
   }
   

   (Only a function pointer wouldn’t be enough because it has to also bring some other data.)

3. Something completely different?

The second option seems a bit better to me since the items could in fact be processed in a single loop without interruption, but it makes the code quite messy as i would have to make quite a lot of derived classes. What would you suggest?

Thanks.

Edit: To be more exact, the storage data type isn’t exactly just an ADT, it has means of only finding only a specific subset of the elements in it based on some parameters, which i need to then process, so i can’t prepare all of them in an array or something.

Answer 1

#include <algorithm>

Have a look at the existing containers provided by the C++ standard, and functions such as for_each.

For a comparison of C++ container iteration to interfaces in “modern” languages, see this answer of mine. The other answers have good examples of what the idiomatic C++ way looks like in practice.

Using templated functors, as the standard containers and algorithms do, will definitely give you a speed advantage over virtual dispatch (although sometimes the compiler can devirtualize calls, don’t count on it).