Call a function with the address extracted from vector of lists, lists are address of functions

#include <list>
#include <vector>
#include <mutex>


typedef std::list<void *> funcList;

typedef struct {
  funcList* functionsList;
  char* listName;
}ListAccess_t;

namespace FuncListManager{
  //namespace {
    std::vector<funcList> funcBuffer;
    std::mutex funcMutex;
 // }

  static size_t findEmptyList() {
    for (size_t index = 0; index < funcBuffer.size(); index++) {
      if (funcBuffer[index].empty()) {
        return index;
      }
    }
    return funcBuffer.size();
  }

  size_t getAvalableListIndex() {
    std::lock_guard<std::mutex> lock(funcMutex);
    if (funcBuffer.size() != findEmptyList()) {
      return findEmptyList();
    }
    else {
      return -1;
    }
  }

  void addFunction(size_t listIndex, void* func) {
    std::lock_guard<std::mutex> lock(funcMutex);
    funcBuffer[listIndex].push_back(func);
  }

  void removeFunction(size_t listIndex, void* func) {
    std::lock_guard<std::mutex> lock(funcMutex);
    if (listIndex < funcBuffer.size()) {
      auto& myFuncList = funcBuffer[listIndex];

      auto it = std::find(myFuncList .begin(), myFuncList .end(), func);

      if (it != myFuncList .end()) {
        myFuncList .erase(it);
      }
    }
  }

  void createFunctionList(size_t capacity) {
    std::lock_guard<std::mutex> lock(funcMutex);
    funcBuffer.resize(capacity);
  }

  funcList* getFunctionListPointer(size_t listIndex) {
    std::lock_guard<std::mutex> lock(funcMutex);
    if (listIndex < funcBuffer.size()) {
      return &funcBuffer[listIndex];
    }
    return nullptr;
  }
}

void (*addNumber_t)(int a, int b);

void addnumber(int a, int b) {
  int c = a + b;
}


int main() {
  
  FuncListManager::createFunctionList(5);
  size_t index = FuncListManager::getAvalableListIndex();

  addNumber_t = &addnumber;
  FuncListManager::addObserver(index, (void*)&addnumber);
  ListAccess_t *listAccess = new ListAccess_t();

  listAccess->functionsList= FuncListManager::getObserverListPointer(index);
  listAccess->listName = "list access";

  ObserverList *list = listAccess->functionsList;

  for (auto& func: *list) {
    ((addNumber_t)func)(1,2); //how to call add function here
    int i = 0;
  }

  FuncListManager::removeFunction(index, (void*)&addnumber);

  return 0;
}

I have to create vector of lists and each list is the collection of address of functions (which are referenced with function pointers). How it is possible to call the functions which are added to the vector of lists?

I don't want to use the classes, it's a library under a namespace.

I tried to call the extracted function from the list, but it throws compilation error.