CALLBACK. Нужна помощь

class ExpressionCalculator
{
private:
    double(ExpressionCalculator::*fn)(double,double,double,double);
public:
    ExpressionCalculator(void);
    ~ExpressionCalculator(void);
 
    double f1(double a, double b, double c, double d);
    double f2(double a, double b, double c, double d);
    double f3(double a, double b, double c, double d);
 
    double Calculate(double a, double b, double c, double d);
 
};

double ExpressionCalculator::Calculate(double a, double b, double c, double d)
{
    double tmp = fn(a,b,c,d);
    return tmp;
}

double tmp = fn(a,b,c,d);

double(ExpressionCalculator::*fn)(double,double,double,double);

fn = &ExpressionCalculator::f3;

double tmp = &fn(a,b,c,d);

#pragma once
#include <math.h>
#include <iostream>
 
enum Errors 
{ 
    DivBy0, 
    Negative,
    InvalidLgArgument
};
 
class CalculatingError
{
private:
    void Negative();
    void DivBy0();
    void InvalidLgArgument();
 
    Errors _error;
 
public: 
 
    CalculatingError(Errors error);
    ~CalculatingError();
 
    void RaiseError();
 
};
 
class ExpressionCalculator
{
private:
    double(ExpressionCalculator::*f)(double,double,double,double);
public:
    ExpressionCalculator(void);
    ~ExpressionCalculator(void);
 
    double f1(double a, double b, double c, double d);
    double f2(double a, double b, double c, double d);
    double f3(double a, double b, double c, double d);
 
    double Calculate(double a, double b, double c, double d);
 
};

#include "ExpressionCalculator.h"
 
CalculatingError::CalculatingError(Errors error)
{
    _error = error;
}
void CalculatingError::RaiseError()
{
    switch(_error)
    {
    case Errors::DivBy0:
        DivBy0();
        break;
    case Errors::Negative:
        Negative();
        break;
    case Errors::InvalidLgArgument:
        InvalidLgArgument();
        break;
    }
}
CalculatingError::~CalculatingError()
{
 
}
void CalculatingError::Negative()
{
    std::cout << "Negative number in sqrt function" << std::endl;
}
void CalculatingError::DivBy0()
{
        std::cout << "Divide by zero" << std::endl;
}
void CalculatingError::InvalidLgArgument()
{
std::cout << "Invalid x in lg(x)" << std::endl;
}
 
 
 
ExpressionCalculator::ExpressionCalculator(void)
{
 
}
ExpressionCalculator::~ExpressionCalculator(void)
{
 
}
double ExpressionCalculator::f1(double a, double b, double c, double d)
{
    f = &ExpressionCalculator::f1;
    double tmp;
    try
    {
        if (a < 0) throw CalculatingError(Errors::Negative);
        if (!(a / 4 - b)) throw CalculatingError(Errors::DivBy0);
        tmp = (2 * c - d + sqrt(23 * a)) / (a / 4 - b);
    }
    catch (CalculatingError ce)
    {
        ce.RaiseError();
    }
    return tmp;
}
double ExpressionCalculator::f2(double a, double b, double c, double d)
{
    f = &ExpressionCalculator::f2;
    double tmp;
    try
    {
        if (c < 0) throw CalculatingError(Errors::Negative);
        if (!(b - a / 2)) throw CalculatingError(Errors::DivBy0); 
        tmp = (c + 4 * d - sqrt(123 * c)) / (b - a / 2);
    }
    catch (CalculatingError ce)
    {
        ce.RaiseError();
    }
    return tmp;
}
double ExpressionCalculator::f3(double a, double b, double c, double d)
{
    f = &ExpressionCalculator::f3;
    double tmp;
    try
    {
        if ((c - 5) < 0 || (c - 5) == 1) throw CalculatingError(Errors::InvalidLgArgument);
        if (!d) throw CalculatingError(Errors::DivBy0);
        if (!(a - b)) throw CalculatingError(Errors::DivBy0);
        tmp = (4 * log(c - 5) - 2 * d + 23) / (a - b);
    }
    catch (CalculatingError ce)
    {
        ce.RaiseError();
    }
    return tmp;
}
 
double ExpressionCalculator::Calculate(double a, double b, double c, double d)
{
    double tmp = &f(a,b,c,d);
    return 0;
}

double ExpressionCalculator::Calculate(double a, double b, double c, double d)
{
    double tmp = &f(a,b,c,d); //чего автор хотел добиться этой строчкой?
    return 0;
}

class CTest
{
    typedef void( CTest::*ptrFunc)(int Val);    
public:
    CTest() {  myfunc = &CTest::Test;  }
    
    void Start(int Val) { myfunc(Val);  } //error C2064: результатом вычисления 
                                                   //фрагмента не является функция, 
                                                   //принимающая 1 аргументов
private:
    void Test(int Val)    {  std::cout<< "Val = "<<Val<<std::endl;    }
    ptrFunc myfunc;
};
 
 
int main (void)
{
    CTest test;
    test.Start(30); 
 
    EndProgramm();
}

//вынес имя указателя на функцию-метод за пределы класса, 
//что бы можно было создавать указатель за пределами класса
class CTest;
typedef void( CTest::*ptrFunc)(int Val);    
                                                            
 
class CTest
{
public:
    //инициализация указателя для тестов
    CTest() {  myfunc = &CTest::Test;  } 
    
   //пример того, как запустить метод класса для объекта изнутри класса
    void Start(int Val)   {  (this->*myfunc)(Val);                 }   
 
    //этот метод должен быть по итогу запущен
    void Test(int Val)    {  std::cout<< "Val = "<<Val<<std::endl; } 
private:
 
    //объявление указателя на метод в качестве данных-членов
    ptrFunc myfunc;  
};
 
 
int main (void)
{
    CTest test;
 
    //пример объявления указателя на функцию-метод извне класса
    ptrFunc myPtr=&CTest::Test; 
   
    //пример запуска метода на который указывает указатель извне класса
    (test.*myPtr)(10);   
 
 
    //этот метод запустит метод на который указывает указатель изнутри класса
    test.Start(30);  
 
    return 0;
}

class ExpressionCalculator
{
public:
    ExpressionCalculator(void);
    ~ExpressionCalculator(void);
 
    double f1(double a, double b, double c, double d);
    double f2(double a, double b, double c, double d);
    double f3(double a, double b, double c, double d);
 
    double test(double a) { return 0;}
    double Calculate(double a, double b, double c, double d);
private:
    typedef double (ExpressionCalculator::*ptrFunc)(double a,double b,double c,double d);
 
    ptrFunc f; //так же нагляднее и понятнее объявлять указатель?
 
    //double(ExpressionCalculator::*f)(double,double,double,double);
};

double ExpressionCalculator::Calculate(double a, double b, double c, double d)
{
    double tmp= (this->*f)(a,b,c,d);
    return tmp;
}

void Foo() { std::cout << "YES!\n";}  //наш подопытный кролик
typedef void (*myPtr)();   //псевдоним для улучшенной читабельности
 
int main()
{
    myPtr test;  //создадим указатель на функцию
    test=&Foo;    //присвоим указателю значение функции
    (*test)();      //запустим на выполнение функцию, на которую указывает указатель
    return 0;
}

class Ctest
{
public:  void Foo() { std::cout << "YES!\n";}
};
 
int main()
{
    Ctest test;
    
    test.Foo(); //все нормальные люди пишут так
    (test.Foo)(); //оказывается, так писать тоже можно
 
    return 0;
}

#include <iostream>
 
class Foo
{
public:
    void func1() const
    {
        std::cout << "Foo::func1()" << std::endl;
    }
 
    void func2() const
    {
        std::cout << "Foo::func2()" << std::endl;
    }
 
    void func3() const
    {
        std::cout << "Foo::func3()" << std::endl;
    }
};
 
int main()
{
    typedef void (Foo::*func_ptr)() const;
 
    func_ptr arr[] = {&Foo::func1, &Foo::func2, &Foo::func3};
 
    Foo obj;
 
    while (true)
    {
        int what;
 
        do
        {
            std::cout << ">: ";
            std::cin >> what;
        }
        while (!(what >= 1 && what <= 3));
 
        (obj.*arr[what - 1])();
    }
 
    return 0;
}

void Foo() { std::cout << "YES!\n";}  //наш подопытный кролик
typedef void (*myPtr)();   //псевдоним для улучшенной читабельности
 
int main()
{
    myPtr test;  //создадим указатель на функцию
    test=&Foo;    //присвоим указателю значение функции
    (*test)();      //запустим на выполнение функцию, на которую указывает указатель
    return 0;
}