#include <iostream>
#include <string>
#include <vector>
#include <boost\spirit.hpp>
using namespace boost::spirit;
std::vector<double> stack;
void calc_push(double d)
{
    stack.push_back(d);
}
void calc_add(char const*, char const*)
{ 
    double b=stack.back();stack.pop_back();
    double a=stack.back();stack.pop_back();
    stack.push_back(a+b);
}
void calc_sub(char const*, char const*)
{ 
    double b=stack.back();stack.pop_back();
    double a=stack.back();stack.pop_back();
    stack.push_back(a-b);
}
void calc_mul(char const*, char const*)
{ 
    double b=stack.back();stack.pop_back();
    double a=stack.back();stack.pop_back();
    stack.push_back(a*b);
}
void calc_div(char const*, char const*)
{ 
    double b=stack.back();stack.pop_back();
    double a=stack.back();stack.pop_back();
    stack.push_back(a/b);
}
void calc_neg(char const*, char const*)
{ 
    double a=stack.back();stack.pop_back();
    stack.push_back(-a);
}

struct calculator : public grammar<calculator>
{
    template <typename ScannerT>
    struct definition
    {
        definition(calculator const& /*self*/)
        {
            expression
                =   term
                    >> *(   ('+' >> term)[&calc_add]
                        |   ('-' >> term)[&calc_sub]
                        )
                ;
            term
                =   factor
                    >> *(   ('*' >> factor)[&calc_mul]
                        |   ('/' >> factor)[&calc_div]
                        )
                ;
            factor
                =   real_p[&calc_push]
                |   '(' >> expression >> ')'
                |   ('-' >> factor)[&calc_neg]
                |   ('+' >> factor)
                ;
        }
        rule<ScannerT> expression, term, factor;
        const rule<ScannerT>& start() const { return expression; }
    };
};

int main()
{
    calculator calc;
    while(true)
    {
        std::string src;
        std::cout<<"expression: ";std::cin>>src;
        if(src=="exit")break;
        parse_info<> info = parse(src.c_str(), calc, space_p);
        if(info.full)
        {
            std::cout<<"-------------------------\n";
            std::cout<<"Parsing succeeded\n";
            std::cout<<"result= "<<stack.back()<<"\n";
            std::cout<<"-------------------------\n";
        }
        else
        {
            std::cout<<"-------------------------\n";
            std::cout<<"Parsing failed\n";
            std::cout<<"error at: " << src << "\n";
            std::cout<<"          ";
            for(size_t i= 0 ;i<info.length+ 1 ;++i)std::cout<<" ";
            std::cout<<"^\n";
            std::cout<<"-------------------------\n";
        }
    }
    return  0 ;
}
 

...\boost_1_30_0\libs\spirit\example\fundamental\calc\calc_plain.cpp
/*=============================================================================
    Spirit v1.6.0
    Copyright (c) 1998-2003 Joel de Guzman
    http://spirit.sourceforge.net/

    Permission to copy, use, modify, sell and distribute this software is
    granted provided this copyright notice appears in all copies. This
    software is provided "as is" without express or implied warranty, and
    with no claim as to its suitability for any purpose.
=============================================================================*/
////////////////////////////////////////////////////////////////////////////
//
//  Plain calculator example.
//
//  [ JDG 5/10/2002 ]
//
////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/core.hpp"
#include <iostream>
#include <string>

////////////////////////////////////////////////////////////////////////////
using namespace std;
using namespace boost::spirit;

////////////////////////////////////////////////////////////////////////////
//
//  Semantic actions
//
////////////////////////////////////////////////////////////////////////////
namespace {

    void    do_int(char const* str, char const* end)
    {
        string  s(str, end);
        cout << "PUSH(" << s << ')' << endl;
    }

    void    do_add(char const*, char const*)    { cout << "ADD\n"; }
    void    do_subt(char const*, char const*)   { cout << "SUBTRACT\n"; }
    void    do_mult(char const*, char const*)   { cout << "MULTIPLY\n"; }
    void    do_div(char const*, char const*)    { cout << "DIVIDE\n"; }
    void    do_neg(char const*, char const*)    { cout << "NEGATE\n"; }
}

////////////////////////////////////////////////////////////////////////////
//
//  Our calculator grammar
//
////////////////////////////////////////////////////////////////////////////
struct calculator : public grammar<calculator>
{
    template <typename ScannerT>
    struct definition
    {
        definition(calculator const& /*self*/)
        {
            expression
                =   term
                    >> *(   ('+' >> term)[&do_add]
                        |   ('-' >> term)[&do_subt]
                        )
                ;

            term
                =   factor
                    >> *(   ('*' >> factor)[&do_mult]
                        |   ('/' >> factor)[&do_div]
                        )
                ;

            factor
                =   lexeme_d[(+digit_p)[&do_int]]
                |   '(' >> expression >> ')'
                |   ('-' >> factor)[&do_neg]
                |   ('+' >> factor)
                ;
        }

        rule<ScannerT> expression, term, factor;

        rule<ScannerT> const&
        start() const { return expression; }
    };
};

////////////////////////////////////////////////////////////////////////////
//
//  Main program
//
////////////////////////////////////////////////////////////////////////////
int
main()
{
    cout << "/////////////////////////////////////////////////////////\n\n";
    cout << "\t\tExpression parser...\n\n";
    cout << "/////////////////////////////////////////////////////////\n\n";
    cout << "Type an expression...or [q or Q] to quit\n\n";

    calculator calc;    //  Our parser

    string str;
    while (getline(cin, str))
    {
        if (str[ 0 ] == 'q' || str[ 0 ] == 'Q')
            break;

        parse_info<> info = parse(str.c_str(), calc, space_p);

        if (info.full)
        {
            cout << "-------------------------\n";
            cout << "Parsing succeeded\n";
            cout << "-------------------------\n";
        }
        else
        {
            cout << "-------------------------\n";
            cout << "Parsing failed\n";
            cout << "stopped at: \": " << info.stop << "\"\n";
            cout << "-------------------------\n";
        }
    }

    cout << "Bye... :-) \n\n";
    return  0 ;
}