Перенаправление указателя при перегрузке оператора в variadic template

#include "stdafx.h"
#include <iostream>
#include <conio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "windows.h"
#include "windowsx.h"
 
using namespace std;
 
int Cur = 0;
 
struct var
{
    int ps; // pointer size
    union
    {
        bool b;
        int i;
        PVOID vp;
        char *pc;
        void *pv;
        int *pi;
        double *pd;
        operator bool & ()
        {
            cout << "### Bool overload operator" << endl;
            return b;
        }
        operator int & ()
        {
            cout << "### Int overload operator" << endl;
            return i;
        }
        operator int * ()
        {
            cout << "### POINTER Int overload operator" << endl;
            return pi;
        }
        operator double * ()
        {
            cout << "### POINTER Double overload operator" << endl;
            return pd;
        }
        operator double & ()
        {
            cout << "### Double overload operator" << endl;
            return pd[0]; // вот тут вопрос
        }
        operator PVOID & ()
        {
            cout << "### PVOID overload operator" << endl;
            return vp;
        }
        operator char * ()
        {
            cout << "### Char[] overload operator" << endl;
            return pc;
        }
        operator void * ()
        {
            cout << "### Void[] overload operator" << endl;
            return pv;
        }
    }d;
};
var **v;
 
template<typename Result, typename... Args>
void call(void * fun, Result& r, Args ... args)
{
    using func_type = Result(_cdecl *)(Args...); // прототип функции
    r = ((func_type)fun) (args...); // вызов функции
}
 
int SomeFunc2();
 
int _tmain(int argc, _TCHAR* argv[])
{
    if(SomeFunc2()==0)
        cout << "End Programm" << endl;
    _getch();
    return 0;
}
 
int SomeFunc2()
{
    int res = 0;
    int b = 2;
    v = new var*[b];//динамическая матрица
    v[0] = new var[10];
    v[1] = new var[6];
    v[0][0].d.i = 10;
    v[0][1].d.pc = new char[100];
    v[0][2].d.pc = new char[100];
    v[0][3].d.vp = NULL;
    v[0][4].d.vp = NULL;
    v[0][5].d.i = NULL;
    v[0][6].d.i = 100;
    v[0][7].d.pc = new char[100];
    v[0][8].d.i = 99;
    v[0][9].d.i = 10;
    //
    v[1][0].d.i = 6;
    v[1][1].d.i = NULL;
    v[1][2].d.pd = new double[10];
    v[1][3].d.pc = new char[100];
    v[1][4].d.i = 99;
    v[1][5].d.i = 10;
    //
    strcpy_s(v[0][1].d.pc, v[0][8].d.i, "msvcr120.dll");
    //
    for (int i = 0; i < 10; i++)
    {
        v[1][2].d.pd[i] = NULL;
    }
    strcpy_s(v[1][3].d.pc, v[1][4].d.i, "123.32");
    // test call with pd[0]
    v[1][2].d.pd[0] = atof(v[1][3].d.pc);
    cout << "Test atof result: " << v[1][2].d.pd[0] << endl;
    v[1][2].d.pd[0] = 0;
    //
    cout << "Library Name: " << v[0][1].d.pc << endl;
    int go = 0;
    v[0][3].d.vp = GetModuleHandleA(v[0][1].d);
    if (!v[0][3].d.vp)
    {
        cout << "Library -NOT- found, try load..." << endl;
        v[0][3].d.vp = LoadLibraryA(v[0][1].d);
        if (!v[0][3].d.vp)
            cout << "Library -NOT- loaded" << endl;
        else
        {
            cout << "Library loaded" << endl;
            go = 2;
        }
    }
    else
    {
        cout << "Library found" << endl;
        go = 1;
    }
    if (go != 0)
    {
        strcpy_s(v[0][2].d.pc, v[0][8].d.i, "atof");//_itoa_s
        cout << "Function Name: " << v[0][2].d.pc << endl;
        v[0][4].d.vp = GetProcAddress((HMODULE)v[0][3].d.vp, v[0][2].d.pc);
        if (!v[0][4].d.vp)
            cout << "Function -NOT- found" << endl;
        else
        {
            cout << "Function found, try call..." << endl;
            //call(v[0][4].d.vp, v[1][1].d, v[1][2].d, v[1][3].d, v[1][4].d, v[1][5].d);
            //call(v[0][4].d.vp, v[1][2].d.pi[0], v[1][3].d);
            //call(v[0][4].d.vp, v[1][2].d, v[1][3].d);
            //v[1][1].d.i = atoi(v[1][3].d.pc);
            Cur = 0;
            //v[1][2].d.pd[Cur] = atof(v[1][3].d.pc); // double
            //call(v[0][4].d.vp, v[1][2].d.pd[Cur], v[1][3].d);
            call(v[0][4].d.vp, v[1][2].d, v[1][3].d);
            if (v[1][2].d.pd[Cur] == NULL)
                cout << "Failed result, error: " << endl;
            else
            {
                //char fStr[100] = "";
                //sprintf_s(fStr, sizeof(fStr), "%f", v[1][2].d.pd[Cur]);
                cout << "Returned DOUBLE PTR[" << Cur << "]: " << v[1][2].d.pd[Cur] << endl;
            }
        }
        if (go == 2)
        {
            FreeLibrary((HMODULE)v[0][3].d.vp);
            cout << "Library cleaned" << endl;
        }
    }
    delete[]v[0][7].d.pc;
    delete[]v[0][2].d.pc;
    delete[]v[0][1].d.pc;
    delete[]v[0];
    delete[]v[1][3].d.pc;
    delete[]v[1][2].d.pd;
    delete[]v[1];
    delete[]v;
    return res;
}

operator double & ()
        {
            cout << "### Double overload operator" << endl;
            return pd[0]; // вот тут вопрос
        }

v[1][2].d.pd[0] = atof(v[1][3].d.pc);

call(v[0][4].d.vp, v[1][2].d, v[1][3].d);

template <typename T>
void print_t()
{
    printf("\n%s\n", __FUNCSIG__);
}
 
template <typename Result, typename... Args>
void call(void * fun, Result& r, Args ... args)
{
    print_t<decltype(call<Result, Args...>)>();
 
    using func_type = Result(_cdecl *)(Args...); // прототип функции
 
    print_t<func_type>();
 
    r = ((func_type)fun) (args...); // вызов функции
}

union test
{
    void * p;
    double d;
};
 
extern "C" double foo1();
extern "C" double foo2();
 
int main()
{
    double f1 = foo1();
    double f2 = foo2();
 
    printf("%lf %lf", f1, f2); //результаты отличаются!
}

double f = 3.14;
// Функция возвращает double и компилятор знает об этом
extern "C" double foo1()
{
    return f;
}
 
extern "C" double foo2()
{
    // Насильно приведенная функция, теперь компилятор думает, что функция возвращает union test
    test (*fp)() = (test(*)())foo1;
    return fp().d;
}

test (*fp)() = (test(*)())foo1;
    return fp().d;

call(v[0][4].d.vp, v[1][2].d, v[1][3].d);

call(v[0][4].d.vp, (double)v[1][2].d, v[1][3].d);

using func_type = Result(_cdecl *)(Args...); // прототип функции

user_function<int>(3);

int a = user_f(3);

template <typename T1>
T GetVar(var v)
{
    int type = v.t;
    bool b = v.d.b;
    int i = v.d.i;
    if(type == 0)
        return b;
    else
        return i;
}

call(v[0][4].d.vp, GetVar(v[1][2]), GetVar(v[1][3]));

template<typename Result, typename... Args>
void call(void * fun, Result& r, Args ... args)
...

int CallFunction(var *&fvar)
{
    int res = 1;
    char ftps[7][20] = {"bool","int","double","PVOID","char *","void *","int *"};
    if (fvar[0].d.i <= 0)
        return 0;
    switch (fvar[0].d.i)
    {
    case 3:
        cout << "### 3 args entering" << endl;
        call(fvar[1].d.vp, GetVar(fvar[2]));
        break;
    case 4:
        cout << "### 4 args entering" << endl;
        call(fvar[1].d.vp, GetVar(fvar[2]), GetVar(fvar[3]));
        break;
    default:
        return -1;
    }
}

template <typename ...Args>
variant<int, double, float, char> call(int retType, Args... args)
{
    switch(retType)
    {
    case 1:
         return call_impl<int>(args...); // ставится в соответствие статический тип возврата и число
         // call_impl имеет реализацию как в первом твоем посте (функция call)
    case 2:
         return call_impl<double>(args...);
    // и т.д.
    }
}

int MySquare(int n)
{
  return n*n;
}  
   push bp                   ;Сохранить регистр указателя базы
   mov bp, sp                ;Адресовать стек регистром bp
   mov bx, word ptr [bp+4]   ;Записать int n в bx
   mov ax, bx                ;Переслать bx в ax
   imul bx                   ;Умножить ax на bx
   jmp short @2@58           ;Перейти к следующей команде
@2@58: 
   pop bp                    ;Восстановить регистр bp
   ret                       ; вернуться в место вызова

#pragma warn -rvl
int MySquare (int n)
{ 
 
/*return n*n; */  
 asm {
         mov ax, word ptr n
         imul bx
        }
}      
#pragma warn .rvl