Знаю ли я основы ООП?

template<typename CharT, typename TraitsT>
size_t count_words
(
   std::basic_istream<CharT, TraitsT>& stream, const std::basic_string<CharT, TraitsT>& word,
   const std::string& delims
)
{
    size_t count = 0;
    std::basic_string<CharT, TraitsT> str;
    while (std::getline(stream, str))
    {
       std::vector<std::basic_string<CharT, TraitsT>> words;
       boost::split(words, str, boost::is_any_of(delims), boost::token_compress_on);
       count += std::count(words.begin(), words.end(), word);
    }
    return count;
}
 
template<typename CharT, typename TraitsT>
size_t calc_checksum(std::basic_istream<CharT, TraitsT>& stream)
{
    size_t sum = 0;
    while (!stream.eof())
    {
        int current = 0;
        stream.read(reinterpret_cast<char*>(&current), sizeof(current));
        sum += current;
    }
    return sum;
}

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);
}

struct CommandRegistry {
  static void CalculateWordsCount(const Arguments& args);
  static void CalculateChecksum  (const Arguments& args);
  static void PrintHelp          (const Arguments& args);
};
 
int main(char* argv[], int argc) {
  CommandExecutor cmdExecutor;
  cmdExecutor.register("word"    , std::bind(CommandRegistry::CalculateWordsCount, _1));
  cmdExecutor.register("checksum", std::bind(CommandRegistry::CalculateChecksum  , _1));
  cmdExecutor.register("help"    , std::bind(CommandRegistry::PrintHelp          , _1));
 
  Arguments args(argv, argc);
  cmdExecutor.execute(args.has('m')? args.get('m') : 'help', args);
}