Since it's all known at compile-time, there is Boost.Fusion. Below's my first encounter with it

Code:
#include <iostream>
#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/algorithm/iteration/for_each.hpp>

//some random structs with random methods
struct A
{
    void foo(int& n) const  { ++n; }
};

struct B
{
    void bar(int& n) const { n *= 2; }
    void foobar(int& n) const { n += 17; }
};

//functors to call each of the member functions
struct Foo
{
    const A& a;
    Foo(const A& a): a(a) {}
    void operator() (int& i) const { a.foo(i); }
};

struct Bar
{
    const B& b;
    Bar(const B& b): b(b) {}
    void operator() (int& i) const { b.bar(i); }
};

struct FooBar
{
    const B& b;
    FooBar(const B& b): b(b) {}
    void operator() (int& i) const { b.foobar(i); }
};

//what the name says
struct ApplyFunctionToArray
{
    int* arr;
    unsigned size;
    ApplyFunctionToArray(int* arr, unsigned size): arr(arr), size(size) {}
    template <class Func>
    void operator() (const Func& f) const
    {
        for (unsigned i = 0; i != size; ++i) {
            f(arr[i]);
        }
    }
};

int main()
{
    A a;
    B b;
    boost::fusion::vector<Foo, Bar, FooBar> funcs((Foo(a)), Bar(b), FooBar(b));
    const unsigned size = 4;
    int arr[size] = { 1, 2, 3, 4 };
    for_each(funcs, ApplyFunctionToArray(arr, size));
    for (unsigned i = 0; i != size; ++i) {
        std::cout << arr[i] << '\n';
    }
}
But first, have you actually profiled the application and determined it is slow where you think it is? Or are you just trying to optimize upfront? Next, are you sure you need to call this code that many times? Then, are you sure you are not missing obvious optimizations (e.g why does std::list seem to be your container of choice)? Next, how big do you expect the speed gain to be and are you sure that your approach helps you achieve it in the first place?