Eu gostaria de definir uma função tendo 2 argumentos

 double func(double t, double x); 

onde a implementação real é lida a partir de um arquivo de texto externo.
Por exemplo, especificando no arquivo de texto

function = x*t;    

a função deve implementar a multiplicação entrex et, para que pudesse ser chamado posteriormente. Estou tentando analisar a função usando boost :: spirit. Mas não sei como alcançá-lo.

Abaixo, criei uma função simples que implementa a multiplicação. Eu o vinculo a uma função de impulso e posso usá-lo. Também criei uma gramática simples, que analisa a multiplicação entre dois duplos.

#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include "boost/function.hpp"
#include "boost/bind.hpp"
#include <boost/spirit/include/qi_symbols.hpp>
#include <iostream>
#include <string>

namespace qi = boost::spirit::qi;
namespace ascii=boost::spirit::ascii;
using boost::spirit::ascii::space;
using boost::spirit::qi::symbols;

template< typename Iterator >
struct MyGrammar : public virtual qi::grammar<  Iterator,  ascii::space_type >
{
    MyGrammar() : MyGrammar::base_type(expression)
    {
        using qi::double_;
        //The expression should take x and t as symbolic expressions
        expression = (double_ >> '*' >> double_)[std::cout << "Parse multiplication: " << (qi::_1 * qi::_2)];
     }

     qi::rule<Iterator, ascii::space_type> expression;
 };

double func(const double a, const double b)
{
    return a*b; //This is the operation to perform
}

int main()
{
    typedef std::string::const_iterator iterator_Type;
    typedef MyGrammar<iterator_Type> grammar_Type;

    grammar_Type calc; 

    std::string str = "1.*2."; // This should be changed to x*t

    iterator_Type iter = str.begin();
    iterator_Type end = str.end();
    bool r = phrase_parse(iter, end, calc, space);

    typedef boost::function < double ( const double t,
                                       const double x) > function_Type;

    function_Type multiplication = boost::bind(&func, _1, _2);

    std::cout << "\nResult: " << multiplication( 2.0, 3.0) << std::endl;

    return 0;
}

Se eu modificar a configuração de código acima

std::string str = "x*t";

como posso analisar essa expressão e vinculá-la à funçãomultiplication de tal forma que, se eu ligarmultiplication(1.0, 2.0), associa t a 1,0, x a 2,0 e retorna o resultado da operação?