how to create a general pointer which can deal with int and double variables and avoid scoping issues?

Question

I have some C code where I need to do some calculations with an array of data. The data can be either INT or DOUBLE. In order to deal with the different data types, I was thinking of using an if / else statement and define the pointer holding the data inside that statement:

/* put values into M, depending on data type*/
if (data_type == 2)
{
    double *M;  
    M = somefunction(DOUBLE);
} else {
    unsigned int *M;
    M = somefunction(UINT16);
}

/* dummy code - usually I do some calculations on M which are data type independent */
for (i=0;i<(10);i++) {
    M[i]=0;
}

This leads to scoping problems because M is not defined outside the if / else construct:

 error: ‘M’ undeclared (first use in this function)

If I move the definition of M outside the if / else statement, the code will compile but M inside the if / else is a different M outside.

So I can circumvent the problem by defining two pointers, one double and one int and check everywhere in my code which type I'm dealing with:

double *Mdouble;  
unsigned int *Mint;
/* put values into M, depending on data type*/
if (data_type == 2)
{
    Mdouble = somefunction(DOUBLE);
} else {
    Mint = somefunction(UINT16);
}

/* dummy code - usually I do some calculations on M which are data type independent */
for (i=0;i<(10);i++) {
    if (data_type == 2) {
        Mdouble[i]=0;
    } else {
        Mint[i]=0;
    } 
}

So here's my question:

How can I solve this problem where M is a double or int, depending on my incoming data? Could I solve this with some kind of pointer to a pointer work around? I don't want to write duplicate code for each case.

EDIT could template functions or overloading of functions solve my problem? I'm flexible regarding a C / C++ specific solution

Answer 1

You're going to have to write duplicate code.

At the base level, the required machine code for adding two numbers is different for integers vs floating-point numbers.

This difference is "hidden" since data is typed, so the compiler always knows the type of each operand and can generate the proper code.

If you want to move that information until run-time, the compiler can no longer do its thing, so you're going to have to do it instead and make sure your code takes the proper path.

Answer 2

You can try to use an C union:

#include <string.h>
#include <stdio.h>

int main(int argc, char** argv) {
  union MyUnion {
    int I;
    double D;
  };
  union MyUnion M[10];
  // Initializing the array to 0 (data type independent)
  memset(M, 0, 10*sizeof(MyUnion));
  M[0].I = 1;
  M[1].D = 1.5;
  if (argc==1) { // It should be "if (data_type==2) {"
                 // but I wanted an example that compiles easily
    printf("%i\n", M[0].I); //somefunction(M[0].I);
  } else {
    printf("%lf\n", M[1].D); //somefunction(M[1].D);
  }
}

Answer 3

In C you will have to use a macro

int8_t* ptr=...;
while(n)
    {
    switch(data_type)
        {
        case TYPE_DOUBLE:
            A_MACRO_THAT_DEFINES_YOUR_OPERATION((double*)ptr);
            ptr+=sizeof(double);
            break;
        case TYPE_INT:
            A_MACRO_THAT_DEFINES_YOUR_OPERATION((int*)ptr);
            ptr+=sizeof(int);
            break;
        }
    --n;
    }

This solution is slow since it needs to test the data type for each element. You can instead write the entire loop as a macro. This will be faster but harder to read.

If you can use C++, use a template instead. Here is a solution using templates:

template<class T>
void doStuff(T* ptr_begin,T* end)
    {
    while(ptr_begin!=ptr_end)
        {
   //   Do stuff
        ++ptr_begin;
        }
    }

void doStuffWrapper(void* ptr_begin,void* ptr_end,uint32_t type)
    {
    switch(type)
        {
        case TYPE_DOUBLE:
            doStuff((double*)ptr_begin,(double*)ptr_end);
            break;
        case TYPE_INT:
            doStuff((int*)ptr_begin,(int*)ptr_end);
            break;
        }
    }

As a side note: I prefer switch-case over if-else in this case since it is easier to maintain, and may produce faster code.

Answer 4

You can use a macro, e.g.:

#define CALCULATIONS(M) do { \
    for (i=0;i<(10);i++) \
        (M)[i]=0; \
    } while (0)

and then in your other code:

if ( data_type == 2 )
{
    double *M = whatever;
    CALCULATIONS(M);
}

See here if you are unfamiliar with the do...while(0) technique

Answer 5

It sounds like you want a templatized function.

But I think the question comes down to, can you put all your work in the function?

template <typename T>
T* somefunction(T data){
    //start old somefunction code
    T* result = new T[10]{data, data, data, data, data, data, data, data, data, data};
    //end old somefunction code

    //begin "calculations on M which are data type independent"
    for(int i = 0; i < 10; i++){
        M[i] = 0;
    }
    return M;
}

So with the above code you could do either double* Mdouble = somefunction(13.13) or short* Mshort = somefunction(13);

The best case scenario is in which M was really a throw away array anyway, in which case you could even allocate the data in the template function's stack frame and avoid using new.