带有歧义标识符的void指针

Question

Pardon any syntax errors. I have C++ code that is setup similar to this:

template<typename T>
void addytox(T *x, T *y, int n)
{
   for(int i = 0; i < n; ++i) {
       x[i] += y[i];
   }
   return;
}


void my_func(void *x, void *y, int n, int dtype)
{
   /* Here is where I am unsure of how to do a simple static cast using 
   the dtype identifier. I want to avoid long code using a switch or 
   if/else that would check all possible conditions, for example having 
   code that looks like this:

      if (dtype == 0) {
          addytox((int*)x, (int*)y, n);
      }
      else if (dtype == 1) {
          addytox((float*)x, (float*)y, n);
      }
      else if (dtype == 2) {
          addytox((double*)x, (double*)y, n);
      }
      else {
          //Print/log some error...
          exit;
      }

      return;
   */
}

The reason the code it setup like this is because my_func is pointing to a NumPy array which could of any type (int, float32, float64, etc), and I am calling my_func from Python via ctypes. I know the C++ will not know what type the NumPy array is, but I can easily get the data type in Python, and pass that into my_func (in this case, integer dtype). What I'd like to know is if I could use that identifier an be able to call function addytox only once, with the proper type cast.

for example:

addytox((cast_type*)x, (cast_type*)y, n));

Is it possible to do something like this in C++, and if so how would I go about doing it?

Thank you.

Answer 1

Unfortunately as I understand the issue, compile time type determination with templates is not going to help you at run time. You are pretty much stuck with a switch-type mechanism to determine the type you need to invoke at runtime.

HOWEVER, there are some brilliant template metaprogramming techniques that I can share. These help bridge the gap between compile and run-time type determination.

// Generic Declaration. Note the default value.
// For any of the TypeId's not specialized, the compiler will give errors.
template<int TypeId = 0>
struct DispatchAddYToX;

// Specialize for typeId = 0, which let's say is int
template<>
struct DispatchAddYToX<0>  // Let's say TypeId 0 = int
{
    enum { MyId = 0 };
    typedef int MyType;

    void dispatch(void* x, void* y, int n, int dType)
    {
        // Expanded version, for clarity.
        if(dType == MyId)
        {
            // Awriiite! We have the correct type ID.
            // ADL should take care of lookup.
            addYToX((MyType*)x, (MyType*)y, n);
        }
        else
        {
            // If not the correct ID for int, try the next one.
            DispatchAddYToX<MyId + 1>::dispatch(x, y, n, dType);
        }
    }
};

// Specialize for typeId = 1, which let's say is float
template<>
struct DispatchAddYToX<1>  // Let's say TypeId 1 = float
{
    enum { MyId = 1 };
    typedef float MyType;

    void dispatch(void* x, void* y, int n, int dType)
    {
        // Nice and compact version
        (dType == MyId) ? addYToX((MyType*)x, (MyType*)y, n) :
                          DispatchAddYToX<MyId + 1>::dispatch(x, y, n, dType);
    }
};

... 
// And so on for the rest of the type id's.

// Now for a C-style wrapper.
// Use this with your python hook
void addYToXWrapper(void* x, void*y, int n, int dType)
{
    // Defaults to start at 0 (int)
    // Will replace the switch statement.
    DispatchAddYToX::dispatch(x, y, n, dType);
}

So in the end, it's a fancy switch table which does almost the same thing. The interface is much cleaner though, in my opinion :)