Как создать общий указатель, который может работать с переменными типа int и double и избежать проблем с областями видимости?

Вам придется писать дубликат кода.

На базовом уровне требуемый машинный код для добавления двух чисел отличается для целых чисел и чисел с плавающей запятой.

Это различие "скрыто", поскольку данные печатаются, поэтому компилятор всегда знает тип каждого операнда и может генерировать правильный код.

Если вы хотите переместить эту информацию до времени выполнения, компилятор больше не сможет выполнить свою задачу, поэтому вам придется делать это вместо этого и убедитесь, что ваш код имеет правильный путь.

Вы можете попробовать использовать C-соединение:

#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);
  }
}

В C вам нужно будет использовать макрос

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;
    }

Это решение выполняется медленно, так как для каждого элемента необходимо проверить тип данных. Вместо этого вы можете написать весь цикл как макрос. Это будет быстрее, но сложнее читать.

Если вы можете использовать C++, используйте вместо этого шаблон. Вот решение с использованием шаблонов:

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;
        }
    }

В качестве побочного примечания: в этом случае я предпочитаю switch-case over if-else, так как он легче поддерживать и может генерировать более быстрый код.

Похоже, вы хотите использовать шаблонную функцию.

Но я думаю, что вопрос сводится к тому, что вы можете поместить всю свою работу в эту функцию?

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;
}

Таким образом, с приведенным выше кодом вы можете сделать либо double* Mdouble = somefunction(13.13) либо short* Mshort = somefunction(13);

Наилучший сценарий - это то, что M действительно было отброшенным массивом в любом случае, и в этом случае вы могли бы даже распределить данные в фрейме стека функций шаблона и избегать использования new.

Вы можете использовать макрос, например:

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

а затем в другом коде:

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

Смотрите здесь, если вы не знакомы с do...while(0)