Сгенерировать все возможные совпадения регулярного выражения

ИЗМЕНИТЬ:

Скажем, моя входная строка была "(bl(ah,eck,le),yap)"

• Первая функция будет извлекать string: "bl(ah,eck,le),yap"
• Before returning it would search for nested parenthesis, this would cause it to recurse:
  • The second function would extract the string: "ah,eck,le"
  • Перед возвратом он будет искать вложенные скобки и не найдет их.
  • Это вернет vector<string>: ["ah", "eck", "le"]
• Первая функция теперь будет содержать: "bl["ah","eck","le"],yap"
• Он не найдет больше круглых скобок для извлечения, поэтому он перейдет к расширению всех внутренних комбинаций: "["blah","bleck","blle"],yap"
• Теперь он мог разделить строку и вернуть: ["blah", "bleck", "blle", "yap"]

Возврат из вашей первой функции - это ваш результат.

ИЗМЕНИТЬ:

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

const char* extractParenthesis(const char* start, const char* finish){
    int count = 0;

    return find_if(start, finish, [&](char i){
        if (i == '('){
            count++;
        }
        else if (i == ')'){
            count--;
        }
        return count <= 0; });
}

vector<string> split(const char* start, const char* finish){
    const char delimiters[] = ",(";
    const char* it;
    vector<string> result;

    do{
        for (it = find_first_of(start, finish, begin(delimiters), end(delimiters));
            it != finish && *it == '(';
            it = find_first_of(extractParenthesis(it, finish) + 1, finish, begin(delimiters), end(delimiters)));
        auto&& temp = interpolate(start, it);
        result.insert(result.end(), temp.begin(), temp.end());
        start = ++it;
    } while (it <= finish);
    return result;
}

vector<string> interpolate(const char* start, const char* finish){
    vector<string> result{ 1, string{ start, find(start, finish, '(') } };

    for (auto it = start + result[0].size();
        it != finish;
        it = find(++start, finish, '('),
        for_each(result.begin(), result.end(), [&](string& i){ i += string{ start, it }; })){
        start = extractParenthesis(it, finish);

        auto temp = split(next(it), start);
        const auto size = result.size();

        result.resize(size * temp.size());

        for (int i = result.size() - 1; i >= 0; --i){
            result[i] = result[i % size] + temp[i / size];
        }
    }
    return result;
}

В зависимости от вашего компилятора вам нужно будет объявить их, так как они вызывают друг друга. Это также приведет к фантастическому сбою, если входная строка искажена. И он не может обрабатывать экранированные управляющие символы.

В любом случае вы можете назвать это так:

const char test[] = "((a,b,c)o(m,v)p,b)";
auto foo = interpolate(begin(test), end(test));

for (auto& i : foo){
    cout << i << endl;
}