Задачи для тренировки и лучшего понимания

///////////////////////////////////////////////////////////////////////////////
// Калькулятор делает то же, что и калькулятор в книжке Страуструпа, т.е.
// вычисляет последовательность арифметических выражений, в которых используются
// круглые скобки. Арифметические выражения должны быть записаны в одной строке, 
// и разделены точкой с запятой. Арифметическим выражением также считается 
// инициализация переменной. Имеются встроенные константы pi и e.
// Пример корректной строки ввода:
// r = 1.5; a = 2 * pi * r; b = a * a
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef std::string             T_str;
typedef double                  T_num;
typedef std::map<T_str, T_num>  T_names_values;
///////////////////////////////////////////////////////////////////////////////
class T_calculator
{
    //-------------------------------------------------------------------------    
    enum
    {
        LEFT_PARENTHESIS   = '(',
        RIGHT_PARENTHESIS  = ')',               
        
        PLUS_SIGN   = '+',
        MINUS_SIGN  = '-',        
 
        ASTERISK    = '*',
        SLASH       = '/',
 
        EQUALS_SIGN = '=',
        SEMICOLON   = ';',        
        FINISH_SYMB = '$'
    };
    //-------------------------------------------------------------------------
    T_names_values  names_values;
    //-------------------------------------------------------------------------
public:
    T_calculator();    
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    bool  calc_expr_list            (const T_str&  s_inp, T_str&  s_out);
    bool  print_expr                (const T_str&  s_inp, T_str&  s_out);    
 
    void  remove_spaces             (T_str&  s);
    bool  calc_expr                 (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_semicolon            (const T_str&  s_inp, T_str&  s_out);
 
    bool  calc_summand              (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_line_of_summand      (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_factor               (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_line_of_factor       (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_add_summand          (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_subtract_summand     (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_minus_factor         (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_expr_in_brackets     (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_name_and_name_init   (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_num                  (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_mult_to_factor       (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_div_into_factor      (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_plus                 (const T_str&  s_inp, T_str&  s_out);
    bool  calc_minus                (const T_str&  s_inp, T_str&  s_out);
    bool  calc_left_parenthesis     (const T_str&  s_inp, T_str&  s_out);
 
    bool  calc_right_parenthesis    (const T_str&  s_inp, T_str&  s_out);
    void  calc_name                 (const T_str&  s_inp, T_str&  s_out, T_str& name);
    bool  calc_name_init            (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_asterisk             (const T_str&  s_inp, T_str&  s_out);
    bool  calc_slash                (const T_str&  s_inp, T_str&  s_out);
    bool  calc_equals_sign          (const T_str&  s_inp, T_str&  s_out);
    bool  calc_symb                 (const char c, const T_str&  s_inp, T_str&  s_out);
};
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_name_init(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    calc_equals_sign  (s_inp, s_out);
    return  calc_expr (s_out, s_out, res);
}
///////////////////////////////////////////////////////////////////////////////
void  T_calculator::calc_name(const T_str&  s_inp, T_str&  s_out, T_str&  name)
{ 
    T_str::const_iterator  str_it = std::find_if(s_inp.begin(), s_inp.end(), 
                                                 std::not1(std::ptr_fun(isalpha)));
    name.assign(s_inp.begin(), str_it);
    s_out.assign(str_it, s_inp.end());
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_name_and_name_init(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_str  name;    
    calc_name(s_inp, s_out, name);    
    bool  bool_res;
    if(s_out[0] == EQUALS_SIGN)
    {
        bool_res = calc_name_init(s_out, s_out, res);
        if(bool_res)
        {                
            names_values[name] = res;
        }            
        return  bool_res; 
    }
    else//После имени нет инициализатора.
    {            
        bool_res = (names_values.count(name) != 0);
        //Если имя уже было инициализировано:
        if(bool_res)
        {
            res = names_values[name];                
        }
        else
        {                
            std::cout << "The variable \"" 
                      << name
                      << "\" is not initialized."
                      << std::endl;                
        }
        return  bool_res; 
    }                
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_equals_sign(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(EQUALS_SIGN, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_semicolon(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(SEMICOLON, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::print_expr(const T_str&  s_inp, T_str&  s_out)
{
    T_num  num_res;
    bool   bool_res = calc_expr(s_inp, s_out, num_res);
    if(bool_res)
    {
        std::cout << num_res
                  << std::endl;
    }
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr_list(const T_str&  s_inp, T_str&  s_out)
{
    if(!print_expr(s_inp, s_out))
    {
        return false;
    }
    switch(s_out[0])
    {
    case FINISH_SYMB:
        return  true;
    case SEMICOLON:
        calc_semicolon(s_out, s_out);
        if(s_out[0] == FINISH_SYMB)
        {
            return true;
        }
        else
        {
            return  calc_expr_list(s_out, s_out);
        }        
    default:
        return false;
    }
}
///////////////////////////////////////////////////////////////////////////////
T_calculator::T_calculator()
{
    names_values["pi"]  = 3.1415926535897932385;                       
    names_values["e"]   = 2.7182818284590452354;
                      
    std::cout << "-> ";
    T_str  s_inp;
    std::getline(std::cin, s_inp);
    if(s_inp.empty()) exit(0);
    remove_spaces(s_inp);
    T_str  s_out;    
    if(!calc_expr_list(s_inp += FINISH_SYMB, s_out))
    {
        std::cout << "Not correct expr.";
    }
    std::cout << std::endl
              << std::endl
              << std::endl;
}
///////////////////////////////////////////////////////////////////////////////
void  T_calculator::remove_spaces(T_str&  s)
{    
    for(;;)
    {
        T_str::size_type  pos = s.find_first_of(" \t");   
        if(pos == T_str::npos)
        {
            break;
        }
        s = s.erase(pos, 1);
    }    
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    return     calc_summand         (s_inp, s_out, res)
            && calc_line_of_summand (s_out, s_out, res);   
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    return     calc_factor         (s_inp, s_out, res)
            && calc_line_of_factor (s_out, s_out, res);   
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_line_of_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{   
    switch(s_inp[0])
    {
    case PLUS_SIGN:
        return     calc_add_summand      (s_inp, s_out, res)
                && calc_line_of_summand  (s_out, s_out, res);
    case MINUS_SIGN:
        return     calc_subtract_summand (s_inp, s_out, res)
                && calc_line_of_summand  (s_out, s_out, res);
    default:
        return  true;
    }
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    switch(s_inp[0])
    {
    case MINUS_SIGN:
        return  calc_minus_factor           (s_inp, s_out, res);
    case LEFT_PARENTHESIS:
        return  calc_expr_in_brackets       (s_inp, s_out, res);    
    default:
        if(isalpha(s_inp[0]))
        {
            return  calc_name_and_name_init (s_inp, s_out, res);
        }
        else
        {
            return  calc_num                (s_inp, s_out, res);
        }        
    }
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_minus_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    bool   bool_res =    calc_minus  (s_inp, s_out)
                      && calc_factor (s_out, s_out, res);
    res *= -1;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_line_of_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{
    switch(s_inp[0])
    {
    case ASTERISK:
        return     calc_mult_to_factor  (s_inp, s_out, res)
                && calc_line_of_factor  (s_out, s_out, res);
    case SLASH:
        return     calc_div_into_factor (s_inp, s_out, res)
                && calc_line_of_factor  (s_out, s_out, res);
    default:
        return  true;
    }
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_add_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_summand;
    bool   bool_res =     calc_plus    (s_inp, s_out)
                       && calc_summand (s_out, s_out, res_summand);
    res += res_summand;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_subtract_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_summand;
    bool   bool_res =     calc_minus   (s_inp, s_out)
                       && calc_summand (s_out, s_out, res_summand);
    res -= res_summand;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_mult_to_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_factor;
    bool   bool_res =     calc_asterisk (s_inp, s_out)
                       && calc_factor   (s_out, s_out, res_factor);
    res *= res_factor;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_div_into_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_factor;
    bool   bool_res =     calc_slash  (s_inp, s_out)
                       && calc_factor (s_out, s_out, res_factor);
    res /= res_factor;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_plus(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(PLUS_SIGN, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_asterisk(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(ASTERISK, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_slash(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(SLASH, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_minus(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(MINUS_SIGN, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr_in_brackets(const T_str&  s_inp, T_str&  s_out, T_num& res)
{
    return     calc_left_parenthesis  (s_inp, s_out)
            && calc_expr              (s_out, s_out, res)
            && calc_right_parenthesis (s_out, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_num(const T_str&  s_inp, T_str&  s_out, T_num& res)
{
    std::istringstream  sin(s_inp);    
    bool  bool_res = ((sin >> res) != 0);
    sin >> s_out;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_left_parenthesis(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(LEFT_PARENTHESIS, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_right_parenthesis(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(RIGHT_PARENTHESIS, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_symb(const char c, const T_str&  s_inp, T_str&  s_out)
{    
    bool  res = (s_inp[0] == c);
    if(res)
    {        
        s_out = s_inp.substr(1);
    }
    return res;    
}
///////////////////////////////////////////////////////////////////////////////
int main()
{    
    for(;;)
    { 
        T_calculator  calculator;        
    }
    return 0;
}