Как я мог улучшить этот код C++

Сначала запишите синтаксис того, что Вы поддерживаете, затем пишете код для поддержки его.

Используя нотацию BNF является большим для этого. И пользование библиотекой Spirit для части кода довольно просто.

Command := ACommand | BCommand

ACommand := 'A' AOperation
AOperation := 'some_operation' | 'some_other_operation'

BCommand := 'B' BOperation
BOperation := 'some_operation_for_B' | 'some_other_operation_for_B'

Это легко переводит в синтаксический анализатор Духа. Каждое порождающее правило стало бы остротой, каждый конечный символ будет переведен в функцию.

#include "stdafx.h"
#include <boost/spirit/core.hpp>
#include <iostream>
#include <string>

using namespace std;
using namespace boost::spirit;

namespace {
    void    AOperation(char const*, char const*)    { cout << "AOperation\n"; }
    void    AOtherOperation(char const*, char const*)    { cout << "AOtherOperation\n"; }

    void    BOperation(char const*, char const*)    { cout << "BOperation\n"; }
    void    BOtherOperation(char const*, char const*)    { cout << "BOtherOperation\n"; }
}

struct arguments : public grammar<arguments>
{
    template <typename ScannerT>
    struct definition
    {
        definition(arguments const& /*self*/)
        {
            command
                =   acommand | bcommand;

            acommand = chlit<char>('A') 
              >> ( a_someoperation | a_someotheroperation );

            a_someoperation = str_p( "some_operation" )           [ &AOperation ];
            a_someotheroperation = str_p( "some_other_operation" )[ &AOtherOperation ];

            bcommand = chlit<char>('B') 
              >> ( b_someoperation | b_someotheroperation );

            b_someoperation = str_p( "some_operation_for_B" )           [ &BOperation ];
            b_someotheroperation = str_p( "some_other_operation_for_B" )[ &BOtherOperation ];

        }

        rule<ScannerT> command;
        rule<ScannerT> acommand, bcommand;
        rule<ScannerT> a_someoperation, a_someotheroperation;
        rule<ScannerT> b_someoperation, b_someotheroperation;

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

template<typename parse_info >
bool test( parse_info pi ) {
  if( pi.full ) { 
    cout << "success" << endl; 
    return true;
  } else { 
    cout << "fail" << endl; 
    return false;
  }
}

int _tmain(int argc, _TCHAR* argv[])
{

  arguments args;
  test( parse( "A some_operation", args, space_p ) );
  test( parse( "A some_other_operation", args, space_p ) );
  test( parse( "B some_operation_for_B", args, space_p ) );
  test( parse( "B some_other_operation_for_B", args, space_p ) );
  test( parse( "A some_other_operation_for_B", args, space_p ) );

    return 0;
}

Вы могли использовать шаблон "команда"...... каждое из Ваших действий будет знать свой идентификатор и операцию и добавлять себя к к списку во время выполнения... затем Вы просто искали бы правильную команду, передали бы ее безотносительно контекста, в котором она нуждается, и она выполнит операцию.

Табличный подход, кажется, соответствует этому, как сказанный mxp. Если у Вас есть другое количество параметров для Ваших функций, у Вас мог бы быть столбец в таблице, которая указывает количество параметров для функции на той же строке.

Вы могли взглянуть в "Табличные Методы" (как описано в "Коде, Завершенном", 2-й выпуск, глава 18). Я думаю, что это - то, что Радостный описывает. Преимущество этого является легкой расширяемостью. Просто необходимо добавить некоторые записи в таблицу. Эта таблица могла быть трудно кодирована или даже загружена во времени выполнения.

Подобный предложению Epaga Вы coul также пытаются решить, это через полиморфизм, специализировав классы выполняет действия для различных случаев. Недостаток здесь состоит в том, что необходимо записать новые классы в случае изменений.

Создайте карту функций. Затем у Вас был бы код как:

consumed_count = token_mapper[tokens[0]](tokens)
remove amount of consumed tokens according to the return value and repeat.

Хотя, я не понимаю Ваш подход так или иначе, Вы собираетесь записать язык, это трудно управиться и негибко.Подумайте об этом: Небольшая разница в сумме аргументов вызывает реальное опустошение на том языке. Поэтому Вы всегда ограничиваетесь 1-3 аргументами на команду.

Я просто использовал бы некоторую комбинацию лексического анализатора/парсера-генератора, но если Вы хотите сделать то, что Вы собираетесь сделать, я предложил бы, чтобы Вы, по крайней мере, разделили сначала с новой строкой, затем с пространством, и имели поэтому ясный способ видеть, было ли предназначено это для предоставления 2 или 3 аргументов.

Важно, даже если Ваш язык был бы сгенерирован машиной, что, если Ваш генератор заканчивает тем, что имел ошибку? Перестали работать рано, часто перестали работать.

Вы хотите разделить это на несколько функций, один для каждого идентификатора, и один для каждой операции.

Инструкция, которую я обычно использую, является экранной высотой. Если у меня не может быть функции в полном соответствии на моем экране, я начинаю думать о распадающихся вещах. Тем путем Вы не должны прокручивать только для наблюдения, куда функция идет. Как я сказал, это - инструкция, не правило, но я нахожу это более практичным для управления структурой.

Если Вы затем хотите проявить подход OO и превратить это в набор классов, Вы можете сделать так, если Вы видите преимущество. Помните всю инфраструктуру, которая идет с ним, все же. Вы могли бы хотеть сохранить это простым.

Dave

Я видел решение этой проблемы, которая работала хорошо: хеш-таблица функций.

Во время компиляции Идеальная Хеш-функция создается для каждой поддерживаемой операции, и операция связана с функцией для вызова (указатель функции является значением в хеше, командная строка является ключом).

Во время времени выполнения функциональность команды называют при помощи командной строки для нахождения функции в хеш-таблице. Затем функция вызвана, передав строку "данных" ссылкой. Каждая функция команды затем анализирует остающуюся строку согласно своим правилам... стратегическая модель также применяется в этой точке.

Заставляет код работать как конечный автомат, который является (по моему скромному мнению), самым легким способом приблизиться к сетевому коду.