How to loop through multiple functions in C++?

The language feature you would need for this is called "Reflection", which is a feature C++ does not have. You will need to explicitly name the functions you want to call.

Well, if you have an array of function pointers, you can do something like this:

void (*myStuff[256])(void);

And then when you want to call each function just dereference each of them as you iterate.

Keep in mind that every function in your array must have the same parameter signature and return type.

Here's a solution using Boost.Function and Boost.Bind in which the loop doesn't need to worry about the parameter signatures of the functions you are calling (I haven't tested it in a compiler, but I have very similar code in a project which I know works):

#include <vector>
#include <boost/function.hpp>
#include <boost/bind.hpp>

using std::vector;
using boost::function;
using boost::bind;

void foo (int a);
void bar (double a);
void baz (int a, double b);

int main()
{
   // Transform the functions so that they all have the same signature,
   // (with pre-determined arguments), and add them to a vector:
   vector<function<void()>> myFunctions;
   myFunctions.push_back(bind(&foo, 1));
   myFunctions.push_back(bind(&bar, 2.0));
   myFunctions.push_back(bind(&baz, 1, 2.0));

   // Call the functions in a loop:
   vector<function<void()>>::iterator it = myFunctions.begin();
   while (it != myFunctions.end())
   {
       (*it)();
      it++;
   }

   return 0;
}

Note that you can do the loop much easier if your compiler supports C++11:

   // Call the functions in a loop:
   for (const auto& f : myFunctions)
   {
      f();
   }

Boost.Bind also supports passing in certain parameters dynamically instead of binding them to pre-determined values. See the documentation for more details. You could also trivially alter the above code to support return values (if they are of the same type), by replacing void with the return type, and altering the loop to do something with the returned value.