Тестовое задание от работадателя. Хотелось бы услышать критику.

#ifndef COMMAND_H
#define COMMAND_H
 
#include<vector>
#include<string>
#include<map>
 
class Command{
    static const int minKeyNumber=2;
    static const int maxKeyNumber=7;
    std::vector<std::string> argv;
    std::map<std::string,std::string> valuekey; 
    void ShowHelp();
    bool parse();
    void PrintToFile(std::ofstream,std::string,std::string);
    void CheckSumFile(std::ifstream);
public:
    Command(int,const char*[]);
    void doAction();
};
 
#endif //COMMAND_H

#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<iterator>
#include<map>
#include<algorithm>
 
#include "Command.h"
 
Command::Command(int count,const char *arg[]){
        if(count==1)
            throw(std::string("Отсутствуют аргументы командной строки\n"));
        if(count>maxKeyNumber)
            throw(std::string("Количество аргументов командной строки превышает допустимое\n"));
        std::copy(arg+1,arg+count,std::back_inserter(argv));
        if(!parse())
            throw(std::string("Работа программы завершена\n"));
}
 
 
void Command::doAction(){
    std::map<std::string,std::string>::iterator it=valuekey.begin();
    while(it!=valuekey.end()){
        switch(it->first[1]){
            case 'h': ShowHelp();
                    break;
            case 'm': if(valuekey.find("-f")!=valuekey.end()){
                                if(it->second=="checksum")
                                    CheckSumFile(std::ifstream(valuekey["-f"].c_str(),std::ios::binary));
            
                                 else PrintToFile(std::ofstream(valuekey["-f"].c_str()),it->second,valuekey["-v"]);
                  
                                 break;
                      }
                      else throw(std::string("Использование ключа \"-m\" предполагает наличие ключа \"-f\"\n"));
            //case newkey: при необходимости можно будет добавить обработку других ключей
        }
        ++it;
    }
}
 
 
bool Command::parse(){
    if(argv.front()=="-h"){
        if(argv.size()!=1)
            throw(std::string("Использование ключа -h не предполагает наличие других аргументов\n"));
        valuekey["-h"];
        return true;
    }
    std::vector<std::string> keys;
    keys.push_back("-f");
    keys.push_back("-m");
    keys.push_back("-v");
    //при необходимости можно добавлять новые ключи
 
    std::vector<std::string>::iterator it=argv.begin();
    while(it!=argv.end()){
        if(std::find(keys.begin(),keys.end(),*it)!=keys.end()){
            if(it+1!=argv.end() && (*(it+1))[0]!='-')
                valuekey[*it]=*(it+1);
            else {
                std::cout<<"Для клуча \""<<*it<<"\" требуется аргумент"<<std::endl;
                return false;
            }
        }
        else {
              std::cout<<"Неопознанный аргумент \""<<*it<<"\""<<std::endl;
              return false;
        }
        it+=2;
    }
 
    if(valuekey.size()<minKeyNumber){
        std::cout<<"Недостаточно аргументов"<<std::endl;
        return false;
    }
    return true;
}
 
 
void Command::ShowHelp(){
    std::cout<<"Использование: test -h | -f filename -m option [-v word]"
                "\n\t-h вывод текущей справки\n"
                "\n\t-f имя файла для чтения/записи\n"
                "\n\t-m может принимать значение \"checksum\" для вычисления контрольной суммы файла\n"
                "или определять количество слов для записи в файл\n"
                "\n\t-v слово для записи в файл\n";
}
 
 
#include <sstream>
 
void Command::PrintToFile(std::ofstream out,std::string number,std::string str){
    if(!out){
        std::cout<<"Невозможно открыть файл "<<valuekey["-f"]<<std::endl;
        return;
    }
    if(str==""){
        std::cout<<"Предполагается наличие ключа \"-v\" с аргументом\n";
        return;
    }
    std::istringstream in(number);
    int num;
    in>>num;
    if(in.rdstate() != std::istream::eofbit){
        std::cout<<"Неправильный аргумент \""<<number<<"\" для ключа \"-m\""<<std::endl;
        return;
    }
    std::fill_n(std::ostream_iterator<std::string>(out," "),num,str);
}
 
 
#include<valarray>
 
void Command::CheckSumFile(std::ifstream in){
    if(!in){
        std::cout<<"Невозможно открыть файл "<<valuekey["-f"]<<std::endl;
        return;
    }
    char *buf;
    in.seekg (0, std::ios::end);
    int length = in.tellg();
    in.seekg (0, std::ios::beg);
    buf=new char[length];
    in.read(buf,length);
    //при необходимости std::valarray<> позволит легко сменить алгоритм получения контрольной суммы
    std::valarray<unsigned>buf32(reinterpret_cast<unsigned*>(buf),(length%sizeof(unsigned) ? length/4+1 : length/4));
    std::cout<<"Контрольная сумма файла: "<<std::showbase<<std::hex<<std::uppercase<<buf32.sum()<<std::endl;
}

#include<iostream>
#include<locale>
#include "Command.h"
 
 
int main(int argc,const char *argv[]){
    std::locale::global(std::locale(""));
    try{
        Command com(argc,argv);
        com.doAction();
    }catch(std::string msg){
        std::cout<<msg<<"Используйте -h для получения справки"<<std::endl;
    }
    return 0;
}

int main(int argc, char *argv[])
{
    for(int i = 0; i < argc; i++)
        printf("%s\r\n",argv[i]);
    return 0;
}

if(!parse())
       throw(std::string("Работа программы завершена\n"));

it+=2;

catch(std::string msg)

class Arguments {
public:
  Arguments(char* argv, int arc);
  
  bool        has(char argumentId) const;
  std::string get(char argumentId) const;
};
 
class Command {
public:
  virtual void execute(const Arguments& arguments) const = 0;
};
 
class WordCalculator {
public:
  WordCalculator(const std::string& fileName);
 
  std::size_t calculate(const std::string& word) const;
};
 
class WordCommand : public Command {
public:
  void execute(const Arguments& arguments) {
    WordCalculator calculator(arguments.get('f'));
 
    std::cout << calculator.calculate(arguments.get('v')) << std::endl;
  }
};
 
typedef unsigned int u32;
 
class ChecksumCalculator {
public:
  ChecksumCalculator(const std::string& fileName);
 
  u32 calculate() const;
}
 
class ChecksumCommand : public Command {
public:
  void execute(const Arguments& arguments) {
    ChecksumCalculator calculator(arguments.get('f'));
 
    std::cout << calculator.calculate() << std::endl;
  }
};
 
class HelpCommand : public Command {
public:
  void execute(const Arguments&) {
    std::cout << "bla bla bla" << std::endl;
  }
};
 
class CommandRegistry {
public:
  static void registerCommand(const std::string& commandName, const std::shared_ptr<Command>& command);
  static std::shared_ptr<Command> getCommand(const std::string& commandName);
}
 
void registerCommands() {
  CommandRegistry::registerCommand("word"    , std::make_shared<WordCommand>());
  CommandRegistry::registerCommand("checksum", std::make_shared<ChecksumCommand>());
  CommandRegistry::registerCommand("help"    , std::make_shared<HelpCommand>());
}
 
int main(char* argv, int argc) {
  registerCommands();
 
  Arguments arguments(argv, argc);
 
  const std::string commandName = arguments.has('m')? arguments.get('m') : 'help';
 
  std::shared_ptr<Command> command = CommandRegistry::getCommand(commandName);
 
  command->execute(arguments);
}