La implementación de escapada más rápida?

Question

Estoy trabajando en un código que normaliza una gran cantidad de datos. Al final del procesamiento, se escribe un número de pares clave = "valor" en un archivo. .

La parte "valor" puede ser cualquier cosa, por lo que en el punto de salida de los valores deben tener ningún comillas incrustadas escaparon como \"

En este momento, estoy usando la siguiente:

outstream << boost::regex_replace(src, rxquotesearch, quoterepl); 
// (where rxquotesearch is boost::regex("\"") and quoterepl is "\\\\\"") 

Sin embargo, gprof muestra que estoy gastando la mayor parte de mi tiempo de ejecución en este método, ya que tengo que llamarlo para cada valor.

Tengo curiosidad si hay una manera más rápida que esta. no puedo usar std :: replace ya que estoy reemplazando un caracter por dos.

Gracias por cualquier consejo.

Answer 1

Si la velocidad es una preocupación que debe utilizar una función escrita a mano para hacer esto. Observe el uso de reserve() para intentar mantener la asignación de memoria (re) al mínimo.

string escape_quotes(const string &before) 
{ 
    string after; 
    after.reserve(before.length() + 4); 

    for (string::size_type i = 0; i < before.length(); ++i) { 
     switch (before[i]) { 
      case '"': 
      case '\\': 
       after += '\\'; 
       // Fall through. 

      default: 
       after += before[i]; 
     } 
    } 

    return after; 
} 

Answer 2

Bueno, aquí hay una implementación usando string :: find y string :: insert, no estoy seguro de si es más rápido, ¡tendrás que resolverlo! Aquí está:

std::string src = "hey there i have \" all \" over the f\"in pla\"ce\""; 
size_t n = 0; 
while ((n=src.find("\"",n)) != std::string::npos) 
{ 
    src.insert(n,"\\"); 
    n+=2; 
} 
std::cout << src << std::endl; 

Qué impreso:

Hola he \ "all \" sobre el f \ "en el Pla \" ce \"

Answer 3

I' No estoy sorprendido de que la expresión regular sea muy lenta aquí: estás usando un gran martillo de uso general para clavar un pequeño clavo. Por supuesto, si terminaras necesitando hacer algo más interesante, la expresión regular podría ganar rápidamente el ventaja en términos de simplicidad.

En cuanto a un enfoque más simple/más rápido, podría intentar escribir la cadena escapada en un búfer separado, un carácter a la vez. Entonces se vuelve trivial agregar los escapes, y no pierdes el tiempo reasignando la cadena o cambiando los caracteres. La mayor dificultad será administrar el tamaño de tu búfer, pero puedes usar un vector para eso y reutilizar el mismo vector para cada cuerda para evitar asignaciones repetidas. La ganancia de eficiencia dependería en gran medida de los detalles de cómo funciona el vector, pero siempre se puede reducir a matrices en bruto y administración de memoria manual, si es necesario.

La rutina podría ser algo como esto, si utilizó el vector:

vector<char> buf; 
for(some_iterator it = all_the_strings.begin(); 
    it != all_the_strings.end(); ++it) 
{ 
    buf.clear(); 
    const string & str = *it; 
    for(size_t i = 0; i < str.size(); ++i) 
    { 
     if(str[i] == '"' || str[i] == '\\') 
      buf.push_back('\\'); 
     buf.push_back(str[i]); 
    } 
    buf.push_back('\0'); 

    // note: this is not guaranteed to be safe, see answer comments 
    const char * escaped = &buf[0]; 

    // print escaped string to file here... 
} 

Answer 4

No tomaría la cadena fuente y construiría una nueva cadena de salida.
Me gustaría iterar a través de la cadena fuente e imprimir cada carácter, si el carácter es una cita, simplemente imprima una "\" antes de imprimirla.