обратите внимание

Смотрите также этот ответ:https://stackoverflow.com/a/21708215 который был основой для EDIT 2 внизу здесь.

---

я увеличил цикл до 1000000, чтобы получить лучшую временную меру.

это мой Python timing:

real    0m2.038s
user    0m2.009s
sys     0m0.024s

вот эквивалент вашего кода, только немного красивее:

#include <regex>
#include <vector>
#include <string>

std::vector<std::string> split(const std::string &s, const std::regex &r)
{
    return {
        std::sregex_token_iterator(s.begin(), s.end(), r, -1),
        std::sregex_token_iterator()
    };
}

int main()
{
    const std::regex r(" +");
    for(auto i=0; i < 1000000; ++i)
       split("a b c", r);
    return 0;
}

сроки:

real    0m5.786s
user    0m5.779s
sys     0m0.005s

---

это оптимизация во избежание построения / выделения векторных и строковых объектов:

#include <regex>
#include <vector>
#include <string>

void split(const std::string &s, const std::regex &r, std::vector<std::string> &v)
{
    auto rit = std::sregex_token_iterator(s.begin(), s.end(), r, -1);
    auto rend = std::sregex_token_iterator();
    v.clear();
    while(rit != rend)
    {
        v.push_back(*rit);
        ++rit;
    }
}

int main()
{
    const std::regex r(" +");
    std::vector<std::string> v;
    for(auto i=0; i < 1000000; ++i)
       split("a b c", r, v);
    return 0;
}

сроки:

real    0m3.034s
user    0m3.029s
sys     0m0.004s

это почти 100% улучшение производительности.

вектор создается до цикла, и может увеличить свою память в первой итерации. После этого нет никакого освобождения памяти clear() вектор поддерживает память и построения строк на месте.

---

еще одно повышение производительности будет чтобы избежать строительства/разрушения std::string полностью, и, следовательно, выделение/освобождение своих объектов.

это предварительный вариант в этом направлении:

#include <regex>
#include <vector>
#include <string>

void split(const char *s, const std::regex &r, std::vector<std::string> &v)
{
    auto rit = std::cregex_token_iterator(s, s + std::strlen(s), r, -1);
    auto rend = std::cregex_token_iterator();
    v.clear();
    while(rit != rend)
    {
        v.push_back(*rit);
        ++rit;
    }
}

сроки:

real    0m2.509s
user    0m2.503s
sys     0m0.004s

конечным улучшением было бы иметь std::vector на const char * как возврат, где каждый указатель char будет указывать на подстроку внутри оригинала s строка c сам по себе. Проблема в том, что вы не можете этого сделать, потому что каждый из них не будет null terminated (для этого см. Использование C++1y string_ref в более поздний образец).

---

это последнее улучшение может быть достигнуто с помощью этого:

#include <regex>
#include <vector>
#include <string>

void split(const std::string &s, const std::regex &r, std::vector<std::string> &v)
{
    auto rit = std::cregex_token_iterator(s.data(), s.data() + s.length(), r, -1);
    auto rend = std::cregex_token_iterator();
    v.clear();
    while(rit != rend)
    {
        v.push_back(*rit);
        ++rit;
    }
}

int main()
{
    const std::regex r(" +");
    std::vector<std::string> v;
    for(auto i=0; i < 1000000; ++i)
       split("a b c", r, v); // the constant string("a b c") should be optimized
                             // by the compiler. I got the same performance as
                             // if it was an object outside the loop
    return 0;
}

---

я построил образцы с clang 3.3 (из ствола) с-O3. Возможно, другие библиотеки регулярных выражений могут работать лучше, но в любом случае распределения/освобождения часто являются хитом производительности.

---

импульс.Регулярное выражение

это boost::regex сроки строка c аргументов пример:

real    0m1.284s
user    0m1.278s
sys     0m0.005s

кодекса boost::regex и std::regex интерфейс в этом примере идентичны, просто необходимо изменить пространство имен и включить.

наилучшие пожелания, чтобы со временем он стал лучше, реализации регулярных выражений c++ stdlib находятся в зачаточном состоянии.

EDIT

для завершения я попробовал это (вышеупомянутое предложение "окончательное улучшение"), и это не улучшило производительность эквивалент std::vector<std::string> &v версия В что-нибудь:

#include <regex>
#include <vector>
#include <string>

template<typename Iterator> class intrusive_substring
{
private:
    Iterator begin_, end_;

public:
    intrusive_substring(Iterator begin, Iterator end) : begin_(begin), end_(end) {}

    Iterator begin() {return begin_;}
    Iterator end() {return end_;}
};

using intrusive_char_substring = intrusive_substring<const char *>;

void split(const std::string &s, const std::regex &r, std::vector<intrusive_char_substring> &v)
{
    auto rit = std::cregex_token_iterator(s.data(), s.data() + s.length(), r, -1);
    auto rend = std::cregex_token_iterator();
    v.clear(); // This can potentially be optimized away by the compiler because
               // the intrusive_char_substring destructor does nothing, so
               // resetting the internal size is the only thing to be done.
               // Formerly allocated memory is maintained.
    while(rit != rend)
    {
        v.emplace_back(rit->first, rit->second);
        ++rit;
    }
}

int main()
{
    const std::regex r(" +");
    std::vector<intrusive_char_substring> v;
    for(auto i=0; i < 1000000; ++i)
       split("a b c", r, v);

    return 0;
}

это имеет отношение к array_ref и string_ref предложение. Вот пример кода, использующего его:

#include <regex>
#include <vector>
#include <string>
#include <string_ref>

void split(const std::string &s, const std::regex &r, std::vector<std::string_ref> &v)
{
    auto rit = std::cregex_token_iterator(s.data(), s.data() + s.length(), r, -1);
    auto rend = std::cregex_token_iterator();
    v.clear();
    while(rit != rend)
    {
        v.emplace_back(rit->first, rit->length());
        ++rit;
    }
}

int main()
{
    const std::regex r(" +");
    std::vector<std::string_ref> v;
    for(auto i=0; i < 1000000; ++i)
       split("a b c", r, v);

    return 0;
}

также будет дешевле вернуть вектор string_ref, а не string копии для случая split С возвращением вектора.

EDIT 2

это новое решение может получить выход путем возврата. Я использовал Маршалла Клоу string_view (string_ref была переименована) реализация libc++ найдена по адресуhttps://github.com/mclow/string_view.

#include <string>
#include <string_view>
#include <boost/regex.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/iterator/transform_iterator.hpp>

using namespace std;
using namespace std::experimental;
using namespace boost;

string_view stringfier(const cregex_token_iterator::value_type &match) {
    return {match.first, static_cast<size_t>(match.length())};
}

using string_view_iterator =
    transform_iterator<decltype(&stringfier), cregex_token_iterator>;

iterator_range<string_view_iterator> split(string_view s, const regex &r) {
    return {
        string_view_iterator(
            cregex_token_iterator(s.begin(), s.end(), r, -1),
            stringfier
        ),
        string_view_iterator()
    };
}

int main() {
    const regex r(" +");
    for (size_t i = 0; i < 1000000; ++i) {
        split("a b c", r);
    }
}

сроки:

real    0m0.385s
user    0m0.385s
sys     0m0.000s

обратите внимание, как быстро это по сравнению с предыдущими результатами. Конечно, это не заполнение vector внутри цикла (ни совпадения ничего заранее, вероятно, тоже), но вы все равно получаете диапазон, который вы можете варьировать с помощью диапазона на основе for, или даже использовать его для заполнения vector.

как ранжирование по iterator_range создает string_view s над оригиналом string(или строка с нулевым завершением), это становится очень легким, никогда не генерируя ненужные выделения строк.

просто для сравнения с помощью этой split реализация, но на самом деле заполнение vector мы могли бы сделать это:

int main() {
    const regex r(" +");
    vector<string_view> v;
    v.reserve(10);
    for (size_t i = 0; i < 1000000; ++i) {
        copy(split("a b c", r), back_inserter(v));
        v.clear();
    }
}

это использует алгоритм копирования диапазона повышения для заполнения вектора в каждой итерации, время:

real    0m1.002s
user    0m0.997s
sys     0m0.004s

как видно, особой разницы по сравнению с оптимизировано string_view выходная версия param.

обратите внимание также есть предложение std::split это будет работать так.