Estou tentando testar (usandoboost::regex) se uma linha em um arquivo contém apenas entradas numéricas separadas por espaços. Encontrei uma exceção que não entendo (veja abaixo). Seria ótimo se alguém pudesse explicar por que é lançado. Talvez eu esteja fazendo algo estúpido aqui na minha maneira de definir os padrões? Aqui está o código:

// regex_test.cpp
#include <string>
#include <iostream>
#include <boost/regex.hpp>
using namespace std;
using namespace boost;

int main(){
  // My basic pattern to test for a single numeric expression
  const string numeric_value_pattern = "(?:-|\\+)?[[:d:]]+\\.?[[:d:]]*";
  // pattern for the full line
  const string numeric_sequence_pattern = "([[:s:]]*"+numeric_value_pattern+"[[:s:]]*)+";

  regex r(numeric_sequence_pattern);
  string line= "1 2 3 4.444444444444";
  bool match = regex_match(line, r);
  cout<<match<<endl;

  //...
}

Eu compilo isso com sucesso com

g++ -std=c++11 -L/usr/lib64/ -lboost_regex regex_test.cpp  

O programa resultante funcionou bem até agora ematch == true como eu queria. Mas então eu testo uma linha de entrada como

string line= "1 2 3 4.44444444e-16"; 

Obviamente, meu padrão não foi criado para reconhecer o formato4.44444444e-16 e eu esperaria issomatch == false. No entanto, em vez disso, recebo o seguinte erro de tempo de execução:

terminate called after throwing an instance of  
'boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<std::runtime_error> >'  
  what():  The complexity of matching the regular expression exceeded predefined bounds.  
Try refactoring the regular expression to make each choice made by the state machine unambiguous.  
This exception is thrown to prevent "eternal" matches that take an indefinite period time to locate.  

Por que é que?
Nota: o exemplo que dei é extremal, no sentido de que colocar um dígito a menos depois que o ponto funciona bem. Que significa

string line= "1 2 3 4.4444444e-16";

apenas resulta emmatch == false como esperado. Então, eu estou confuso. O que esta acontecendo aqui?

Obrigado já!

Atualizar:
Problema parece estar resolvido. Dada a dica dealejrb Refatorei o padrão para

const string numeric_value_pattern = "(?:-|\\+)?[[:d:]]+(?:\\.[[:d:]]*)?";  

Isso parece funcionar como deveria. De alguma forma, o opcional isolado\\. dentro do padrão original[[:d:]]+\\.?[[:d:]]* resta muitas possibilidades para combinar uma longa sequência de dígitos de maneiras diferentes.
Espero que o padrão esteja seguro agora. No entanto, se alguém encontrar uma maneira de usá-lo para uma explosão na nova forma, me avise! Não é tão óbvio para mim se isso ainda é possível ...