使用map解析命令< const string，function&lt ;? （ω）>>命令; [英] Parsing commands using map<const string, function<? (?)>> commands;

问题描述

问题陈述：

给定交互式输入，请调用适当的对象（Bank，BankRegister，BasicAccount等） 。）。

输入（每个命令在单独的行上）：

  create_bank< bank_name> \\\
 
 create_customer< bank_number> < customer_name> \\\
 
 create_account< bank_number> < customer_number> \\\
 
 deposit< amount> < account_number> /< bank_number> \ n 
 etc ... 
  

strong>建议解决方案：

  #include< functional& 
 
 bool create_bank（const string& arguments）{
 const string& bankName = arguments; //不需要在这里解析
 bank Register.registerBank（new Bank（bankName，
& bankRegister））; //无法访问bankRegister！ 
 return true; 
} 
 
 int main（）{
 map< string，function< bool（string）>命令; 
 commands.emplace（create_bank，create_bank）; 
 ... 
银行注册银行
 
 string命令，arguments; 
 cin>>命令; 
 getline（cin，arguments）; 
 commands [command]（arguments）; 
 ... 
} 
  

1. 无法从函数访问bankRegister对象。我可能通过它的常量引用的函数，但只有一些函数需要它。我想的是使其成员（m_banks，m_next_bankNumber）静态，但后来我必须将它们公开，这可能是一个不好的设计决策。


2. 参数解析应该在哪里发生？这是否可以这样？



3. 返回值应该代表什么？

   
   
   

   a）参数parsed successfully

   
   
   

   b）参数已成功解析并成功执行命令

   
   
   

   我使用异常处理某些错误，除了cerr。




4. 我可以在这里使用可变参数解析参数吗？



5. c> create_bank 函数并使用 std :: bind 绑定 BankRegister 具有调用签名的函数对象 bool（const string&）

     bool create_bank（const string& arguments，BankRegister& bankRegister）{
    const string& bankName = arguments; //不需要在这里解析
    bank Register.registerBank（new Bank（bankName，
   & bankRegister））; 
    return true; 
   } 
    
    int main（）{
    BankRegister bankRegister; 
    map< string，function< bool（string）>>命令; 
    using std :: placeholders :: _ 1; 
    commands.emplace（create_bank，std :: bind（create_bank，_1，std :: ref（bankRegister）））; 
     

   您可以使用lambda函数做同样的事情：

     commands.emplace（create_bank，[& bankRegister]（const string& args）{return create_bank（args，bankRegister）;}）; 
     

   bind 返回的函数对象由lambda表达式创建的关闭对象都具有所需的调用签名 bool（const string&），但它们还包含对 bankRegister object，并可将其传递给 create_bank

   
   

   Problem statement:

   Given the interactive input, call the appropriate methods on appropriate objects (Bank, BankRegister, BasicAccount, etc...).

   input (each command on a separate line):

   create_bank <bank_name>\n
   create_customer <bank_number> <customer_name>\n
   create_account <bank_number> <customer_number>\n
   deposit <amount> <account_number>/<bank_number>\n
   etc...
   

   Proposed solution:

   #include <functional>
   
   bool create_bank(const string& arguments){
       const string& bankName = arguments; //no need to parse here
       bankRegister.registerBank(new Bank(bankName,
                                          &bankRegister)); //can't access bankRegister!
       return true;
   }
   
   int main(){
       map<string, function<bool (string)>> commands;
       commands.emplace("create_bank",create_bank);
       ...
       BankRegister bankRegister;
   
       string command, arguments;
       cin>>command;
       getline(cin, arguments);
       commands[command](arguments);
       ...
   }
   

   Why it does not work:

   1. The bankRegister object can't be accessed from the functions. I might pass it by constant reference to the functions, but only some functions need it. I was thinking of making its members (m_banks, m_next_bankNumber) static, but then I would have to make them public, which is probably a bad design decision.
   2. Where should the argument parsing happen? Is it OK this way?

   3. What should the return value represent?

      a) arguments parsed successfully

      b) arguments parsed successfully and command executed successfully

      I use the exceptions for some of the errors, but some are silent except for cerr.

   4. Could I use variadic functions here to parse the arguments?

   5. Is there something else you would improve?

   解决方案

   You could change the signature of the create_bank function and use std::bind to bind the BankRegister argument, creating a function object with the call signature bool(const string&)

   bool create_bank(const string& arguments, BankRegister& bankRegister){
       const string& bankName = arguments; //no need to parse here
       bankRegister.registerBank(new Bank(bankName,
                                          &bankRegister));
       return true;
   }
   
   int main(){
       BankRegister bankRegister;
       map<string, function<bool (string)>> commands;
       using std::placeholders::_1;
       commands.emplace("create_bank",std::bind(create_bank, _1, std::ref(bankRegister)));
   

   You can do the same thing with a lambda function:

       commands.emplace("create_bank", [&bankRegister](const string& args) { return create_bank(args, bankRegister); });
   

   The function object returned by bind and the closure object created by the lambda expression both have the required call signature, bool(const string&), but they also contain a reference to the bankRegister object and can pass it to create_bank

   这篇关于使用map解析命令< const string，function&lt ;? （ω）>>命令;的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！