C ++ ::成员函数数组

Question

I want to store an array of Member Functions of different Classes. Just a repetition here:

Requirements:

• TypeOf Class
• Instance of Class containing the Function
• AddressOf the Member Function
• Member Function parameters

What I can store:

• Instance of Class containing the Function
• AddressOf the Member Function.
• Member Function parameters

Normally, you don't need to store the Class type whatsoever, since you can make an array pointer to the Class type. The reason I can't do that is because the Class types I take in are unknown and different. The Class is going to be used in many different projects where Class types are unknown.

I need to store different types of Classes into the Array/List, in which case I just stored the addresses of the classes into an array pointer.

My Problem: When I'm about to call the Member Function, I need to cast the Class address to the Class type, but I don't know what the type is to cast to.

Example Code (Not tested - written real quickly):

class A
{
    public:
        void test1(int i);
};

class B
{
    public:
        void test2(char c);
};

class Container
{
    long* objects;
    long* funcs;
    int index;

    public:

        Container()
        {
            objects = new long[5];
            funcs = new long[5];
            index = 0;
        }

        template <class C, typename Types ...>
        void Add(C *obj, void (C::*func)(Types ...))
        {
            objects[index++] = (long)obj;
            funcs[index++] = (long)func;
        }

        typename <Types ...>
        void Call(int inx, Types ... values)
        {
            void (*func)(Types ...) = (void (*)(Types ...))funcs[inx];

            // This is where I've got trouble. I don't store the Class 
            // types, so I don't know what pointer Class type to cast 
            // the Class Instance address to.
            (((*???)objects[inx])->*func)(values ...);
        }
};

Thanks in advance. Ask ahead if there are any holes or any questions.

Answer 1

Can you constrain this a little bit on the signature of the member functions? If so, instead of storing pointers to objects and member functions separately, you can store bound functions.

template<typename... Args>
class Container {
public:
    typedef std::function<void (Args...)> F;

    template <class C>
    void Add(C* obj, void (C::*func)(Args ...))
    {
        functions.push_back( [=](Args... args) {(obj->*func)(args...);} );
    }

    void call(size_t i, Args... args)
    {
        functions[i](args...);
    }

private:
    std::vector<F> functions;
};

Answer 2

IMHO, your posting reads like it might be an interesting polymorphic programming challenge, but with the added requirement, "no polymorphism" ... in which case you are to learn the more difficult approach.

What I have to address your stated problem:

When I'm about to call the Member Function, I need to cast the Class address to the Class type, but I don't know what the type is to cast to.

used to be called a Thunk (back when I first encountered it). In a (relatively) recent search, I have not found this idea under that name (and did find several other things called a thunk). The explanation for the name I once read was something like because "it encapsulates things that I already thunk".

Note that with a thunk, NO casting is required (because you already thunked it)

Use the thunk as the object in your Container.

Oh, and since you marked this C++, you really should use std::vector < PVThunk_t >.

  // ////////////////////////////////////////////////////////////////////
  // Pure Virtual Thunk_t: an abstract base class
  class PVThunk_t
  {
  public:
     virtual ~PVThunk_t(){}

     virtual void operator()(void* v) = 0;
     virtual void exec      (void* v) = 0;
  };
  // pure-virtual requires derived objects to implement both methods

// ///////////////////////////////////////////////////////////////////////
// template class - make it easy to create thunk for any class T
template <class T>
class Thunk_t : PVThunk_t
{
public:
   // constructor - takes pointer to an object and pointer to a member and stores
   // them in two private variables
   Thunk_t( T*    anInstance,        // pointer to an instance of class T
            void* (T::*aMethod)()) : // pointer to a  method   of class T, no parameter, returns void
      m_instance (anInstance),
      m_method   (aMethod)
      {
         assert  (m_instance);
         asssert (m_method);
      }

   Thunk_t( T*  anInstance,        // pointer to an instance of class T
            T*  (T::*aMethod)()) :  // pointer to a  method   of class T, no parameter, returns T*
      m_instance (anInstance),
      m_method   (aMethod)
      {
         assert  (m_instance);
         asssert (m_method);
      }

   virtual ~Thunk_t() { }

   // override operator "()"
   virtual void* operator()(void* v) { return((*m_instance.*m_method)(v)); }

   // override function "exec"
   virtual void* exec(void* v) { return((*m_instance.*m_method)(v)); }

private:
   T*        m_instance;         // pointer to object of T
   void (T::*m_method)(void*);   // pointer to method attribute of T with void* param

}; // template <class T>  class Thunk_t : public PVThunk_t

Note the proper mechanism to declare m_instance and m_method pointers.

---

If you need to use methods with a variable number of parameters, I suggest passing a struct pointer (with appropriate adjustments or additions to the Thunk. The single method parameter would always be a pointer to the struct, and its type or content can then be inferred by the method invoked.

I have not used this Thunk for a long time, because, well, polymorphism is superior in every way. But Thunk still compiles, so it will probably work.

update - noticed that the virtual methods didn't match. fixed