Más segura, fácil de usar y flexible alternativa de C++ a sscanf()

Question

Cuando necesito escanear valores de varias cadenas, a menudo me encuentro recurriendo a C sscanf() estrictamente debido a su simplicidad y facilidad de uso. Por ejemplo, de manera muy sucinta puedo tirar un par de valores dobles de una cadena con:

string str; 
double val1, val2; 
if (sscanf(str.c_str(), "(%lf,%lf)", &val1, &val2) == 2) 
{ 
    // got them! 
} 

Esto, obviamente, no es muy C++. No necesariamente lo considero una abominación, pero siempre estoy buscando una mejor manera de hacer una tarea común. Entiendo que el "modo C++" para leer cadenas es istringstream, pero el tipeo extra requerido para manejar los paréntesis y la coma en la cadena de formato de arriba simplemente lo hace demasiado engorroso para hacer que quiera usarlo.

¿Hay una buena manera de doblar las instalaciones integradas a mi voluntad de una manera similar a la anterior, o hay una buena biblioteca de C++ que hace lo anterior de una manera más segura? Parece que Boost.Format realmente ha resuelto el problema de salida de una buena manera, pero no he encontrado nada similar para la entrada.

Answer 1

me escribió un poco de código que puede leer en la cadena de caracteres y literales. Al igual que las lecturas de transmisión normales, si obtiene datos no válidos, establece el bit de la secuencia. Esto debería funcionar para todo tipo de transmisiones, incluidas las extensas. Se adhieren este bit en una nueva cabecera:

#include <iostream> 
#include <string> 
#include <array> 
#include <cstring> 

template<class e, class t, int N> 
std::basic_istream<e,t>& operator>>(std::basic_istream<e,t>& in, const e(&sliteral)[N]) { 
     std::array<e, N-1> buffer; //get buffer 
     in >> buffer[0]; //skips whitespace 
     if (N>2) 
       in.read(&buffer[1], N-2); //read the rest 
     if (strncmp(&buffer[0], sliteral, N-1)) //if it failed 
       in.setstate(in.rdstate() | std::ios::failbit); //set the state 
     return in; 
} 
template<class e, class t> 
std::basic_istream<e,t>& operator>>(std::basic_istream<e,t>& in, const e& cliteral) { 
     e buffer; //get buffer 
     in >> buffer; //read data 
     if (buffer != cliteral) //if it failed 
       in.setstate(in.rdstate() | std::ios::failbit); //set the state 
     return in; 
} 
//redirect mutable char arrays to their normal function 
template<class e, class t, int N> 
std::basic_istream<e,t>& operator>>(std::basic_istream<e,t>& in, e(&carray)[N]) { 
     return std::operator>>(in, carray); 
} 

Y hará que los caracteres de entrada muy fácil:

std::istringstream input; 
double val1, val2; 
if (input >>'('>>val1>>','>>val2>>')') //less chars than scanf I think 
{ 
    // got them! 
} 

PROOF OF CONCEPT. Ahora puede cin literales de cadena y caracteres, y si la entrada no es una coincidencia exacta, actúa igual que cualquier otro tipo que no haya podido ingresar correctamente. Tenga en cuenta que esto solo coincide con el espacio en blanco en los literales de cadena que no son el primer carácter. Son solo cuatro funciones, todas las cuales son cerebrales simples.

EDITAR

Analizar con las corrientes es una mala idea. Usa una expresión regular

Answer 2

Creo que con la expresión regular podría hacerse fácilmente. Así que boost :: regex o std :: regex en un nuevo estándar. Después de eso simplemente convierta sus tokens para flotar usando lexical_cast o streams directamente.

Answer 3

Lo mejor que he usado para el análisis de cadenas es boost.spirit. Es rápido, seguro y muy flexible. La gran ventaja es que se puede escribir reglas de análisis en forma estrecha a la gramática EBNF

using namespace boost::spirit; 

boost::fusion::vector < double, double > value_; 

std::string string_ = "10.5,10.6 "; 

bool result_ = qi::parse(
    string_.begin(), 
    string_.end(), 
    qi::double_ >> ',' >> qi::double_, // Parsing rule 
    value_); // value