Multi-remplacement rapide en chaîne

J’ai une chaîne comme celle-ci:

{A}jahshs{b}jwuw{c}wuqjwhaha{d}{e}{f}jsj{g} 

Et je dois remplacer chaque {x} par une chaîne différente. Le problème vient du fait que ce processus sera répété environ 1000 fois / seconde, il me faut donc un moyen optimisé / rapide pour le faire.

Une idée? Boost remplacer? Boost format? Etc..

  1. préallouer tous les tampons

    ….

  2. profit

Oh, et ne spammez pas. Exemple de code en 5 à 10 minutes.

Ok va ici: aussi Live On Coliru

 #include  #include  #include  template  int expand(Range const& /*key*/) { return rand()%42; // todo lookup value with key (be sure to stay lean here) } #include  int main() { static const std::ssortingng msg_template = "{A}jahshs{b}jwuw{c}wuqjwhaha{d}{e}{f}jsj{g}\n"; std::ossortingngstream builder; builder.str().reserve(1024); // reserve ample room, not crucial since we reuse it anyways for (size_t iterations = 1ul << 14; iterations; --iterations) { builder.str(""); std::ostreambuf_iterator out(builder); for(auto f(msg_template.begin()), l(msg_template.end()); f != l;) { switch(*f) { case '{' : { auto s = ++f; size_t n = 0; while (f!=l && *f != '}') ++f, ++n; // key is [s,f] now builder << expand(boost::string_ref(&*s, n)); if (f!=l) ++f; // skip '}' } break; default: *out++ = *f++; } } // to make it slow, uncomment: // std::cout << builder.str(); } } 

Cela fonctionne dans ~ 0.239s sur mon système. C'est environ 68k expansions / seconde . Oops. Dans la version release, il effectue 4 millions d’expans / seconde. Sur le Coliru, il atteint presque 1 million d'expansions / seconde .

Marge d'amélioration:

  • vous pouvez prédire l'entrée
  • Si vous savez que les clés de paramètre sont toujours composées d'une lettre, vous pouvez simplement remplacer le paramètre ssortingng_ref par le caractère, et ne pas utiliser la boucle pour le '}' .
  • vous pouvez précalculer les indices des arguments et avancer. L'avantage ici n'est pas si certain (l'access à la mémoire séquentielle est très bon sur certains processeurs et l'approche naïve peut être plus rapide)