Can you make a vector of functions with parameters?

Question

Is it possible to create a vector that has functions pushed back?
I've tried doing something with pointers, but it only works with functions without parameters.

For example,

#include <iostream>
#include <vector>

using namespace std;

void printInt();

int main()
{
    vector<void (*)()> functionStack;

    functionStack.push_back(printInt);

    (*functionStack[0])();
}

void printInt()
{
    cout << "function works!" << 123 << endl;
}

That works, but not what I need.
The correct version of that would be a function that has parameters: void printInt(int a) and you could call it with different values like 4 or -1 but from the vector functionStack.

It's probably more complex if the functions in the vector are with different parameters, so let's assume that every function has the same type and amount of parameters.

Answer 1

This:

void (*)()

is a function pointer taking no arguments. So change it to take the desired argument.

void (*)(int)

Like so:

void printInt(int x)
{
    cout << "function works!" << x << endl;
}

int main()
{
    vector<void (*)(int)> functionStack;

    functionStack.push_back(printInt);

    (*functionStack[0])(123);
}

You are correct in saying the functions must have the same type and number of parameters for this to be valid.

Answer 2

You basically had it already.

#include <iostream>
#include <vector>

using namespace std;

void printInt(int a);

int main()
{
    // Just needed the parameter type
    vector<void (*)(int)> functionStack;

    // Note that I removed the () from after the function
    // This is how we get the function pointer; the () attempts to
    // invoke the function
    functionStack.push_back(printInt);

    (*functionStack[0])(42);
}

void printInt(int a)
{
    cout << "function works! " << a << endl;
}

This is also a situation where std::function might be beneficial as well.

#include <iostream>
#include <functional>
#include <vector>

using namespace std;

void printInt(int a);

int main()
{
    // Similar syntax, std::function allows more flexibility at a 
    // lines of assembly generated cost. But it's an up-front cost
    vector<std::function<void(int)>> functionStack;

    functionStack.push_back(printInt);

    // I don't have to de-reference a pointer anymore
    functionStack[0](42);
}

void printInt(int a)
{
    cout << "function works! " << a << endl;
}