Editar 3

Eu fui para a abordagem de análise personalizada good'ol como eu fiquei preso com a expressão regular. Não foi tão ruim assim, já que o conteúdo do arquivo pode ser simbolizado de forma bastante precisa e os tokens podem ser analisados ​​em um loop com ummuito máquina de estado simples. Aqueles que querem verificar, há um snippet de código fazendo isso com iteradores ifstream de intervalo e tokenizer de fluxo personalizado na minha outra pergunta no StackoverflowAqui. Essas técnicas reduzem consideravelmente a complexidade de fazer um analisador personalizado.

Eu gostaria de tokenize o conteúdo do arquivo na primeira parte em grupos de captura de dois e, em seguida, apenas linha por linha. Eu tenho uma solução semi-funcional, mas gostaria de aprender como melhorar isso. Ou seja, sem "processamento extra" para compensar minha falta de conhecimento com grupos de captura. Em seguida, algumas preliminares e no final uma pergunta mais exata (a linha

const std::regex expression("([^:]+?)(^:|$)");

... é o que eu gostaria de perguntar em combinação com o processamento dos resultados dele).

Os arquivos que são basicamente definidos assim:

definition_literal : value_literal
definition_literal : value_literal
definition_literal : value_literal
definition_literal : value_literal
HOW TO INTERPRET THE FOLLOWING SECTION OF ROWS
[DATA ROW 1]
[DATA ROW 2]
...
[DATA ROW n]

Onde cada uma das linhas de dados consiste em um certo número de números inteiros ou números de ponto flutuante separados por espaço em branco. Cada linha tem tantos números quanto os outros (por exemplo, cada linha pode ter quatro inteiros). Assim, a "seção de interpretação" basicamente diz este formato em texto simples em uma linha.

Eu tenho uma solução quase de trabalho que lê esses arquivos como este:

int main() 
{
    std::ifstream file("xyz", std::ios_base::in);
    if(file.good())
    {
        std::stringstream file_memory_buffer;
        file_memory_buffer << file.rdbuf();
        std::string str = file_memory_buffer.str(); 
        file.close();

        const std::regex expression("([^:]+?)(^:|$)");
        std::smatch result;

        const std::sregex_token_iterator end;       
        for(std::sregex_token_iterator i(str.begin(), str.end(), expression); i != end; ++i)
        {
            std::cout << (*i) << std::endl;
        }
    }

    return EXIT_SUCCESS;
}

Com o regex definidoexpression, agora imprime o<value> partes do arquivo de definição, em seguida, a parte de interpretação e, em seguida, as linhas de dados, uma por uma. Se eu mudar o regex para

"([^:]+?)(:|$)"

... imprime todas as linhas simbolizadas em grupos de um, quase como eu gostaria, mas como separar a primeira parte em grupos de dois e o resto linha por linha?

Qualquer ponteiros, código, explicações são realmente bem-vindas. Obrigado.

EDITAR:

Conforme observadoTom Kerr já, mas alguns pontos adicionais, este é também um ensaio, ou codificação kata se quiser, para não escrever um analisador personalizado, mas para ver se eu poderia - ou poderíamos :-) - fazer isso com regex. Eu sei que regex não é a coisa mais eficiente para fazer aqui, mas isso não importa.

O que eu espero ter é algo como uma lista de tuplas de informação de cabeçalho (tupla de tamanho 2), então a linha INTERPRET (tupla de tamanho 1), que eu poderia usar para escolher uma função sobre o que fazer com os dados linhas (tupla de tamanho 1).

Sim, a linha "COMO INTERPRETAR" está contida em um conjunto de cadeias bem definidas e eu poderia ler linha por linha desde o início, dividindo as cadeias ao longo do caminho, até que uma das linhas INTERPRET seja atendida. Esta solução de regex não é o método mais eficiente, eu sei, mas mais como codificar kata para eu mesmo escrever algo diferente de analisadores de clientes (e já faz algum tempo que eu escrevo em C ++ da última vez, então isso também está ensaiando ).

EDIT 2

Eu consegui ter acesso às tuplas (no contexto desta questão), alterando o tipo de iterador, como assim

const std::sregex_iterator end;     
for(std::sregex_iterator i(str.begin(), str.end(), expression); i != end; ++i)
{
    std::cout << "0: " << (*i)[0] << std::endl;
    std::cout << "1: " << (*i)[1] << std::endl;
    std::cout << "2: " << (*i)[2] << std::endl;
    std::cout << "***" << std::endl;
}

Embora isso ainda esteja longe do que eu gostaria de ter, há algo errado com a expressão regular que estou tentando usar. De qualquer forma, essa nova descoberta, outro tipo de iterador, também ajuda.