regex with only numbers in a string c++

Question

I'm looking for a regex to find numbers in a string; if I have a string like:

li 12.12 si 43,23 45 31 uf 889 uf31 3.12345

I want to find only the numbers:

12.12 45 31 889 3.12345

I tried with the following pattern:

((\\+|-)?[[:digit:]]+)(\\.(([[:digit:]]+)?))?

but the output included uf31 and 43,23.

I tried with:

(?!([a-z]*((\\+|-)?[[:digit:]]+)(\\.(([[:digit:]]+)?))?[a-z]*))?((\\+|-)?[[:digit:]]+)(\\.(([[:digit:]]+)?))?

but this gave the same result.

What is the solution?

SOLUTION leave to posterity the solution:

• If you're looking for a simple and effective solution that does not use the regex, see Jonathan Mee's post below

• If you're looking for a solution using RegEx, see the wonderful regex from stribizhev

  R"((?:^|\s)([+-]?[[:digit:]]+(?:\.[[:digit:]]+)?)(?=$|\s))"

Answer 1

Actually, C++ regex module supports look-aheads.

Here is my suggestion:

#include <iostream>
#include <regex>
using namespace std;

int main() {
    std::string buffer = " li 12.12 si 43,23 45 31 uf 889 uf31 3.12345";
    std::regex rx(R"((?:^|\s)([+-]?[[:digit:]]+(?:\.[[:digit:]]+)?)(?=$|\s))"); // Declare the regex with a raw string literal
    std::smatch m;
    std::string str = buffer;
    while (regex_search(str, m, rx)) {
        std::cout << "Number found: " << m[1] << std::endl; // Get Captured Group 1 text
        str = m.suffix().str(); // Proceed to the next match
    }  
    return 0;
}

See IDEONE demo

Due to the raw string literal declaration, there is no need using double backslashes with \s.

The lookahead (?=$|\s) checks the presence, but does not consume the whitespace and consecutive numbers can be extracted.

Note that if you need to extract decimal values like .5, you need

R"((?:^|\s)([+-]?[[:digit:]]*\.?[[:digit:]]+)(?=$|\s))"

Answer 2

You need this regex:

(?<!,)\b([\d\.]+)\b(?!,)

Answer 3

As is stated by stribizhev this can only be accomplished via look arrounds. Since a single whitespace separating numbers would otherwise be needed to be consumed in the search for the number before and after the whitespace.

user2079303 poses a viable option to regexes which could be simplified to the point where it rivaled the simplicity of a regexes:

for_each(istream_iterator<string>(istringstream(" li 12.12 si 43,23 45 31 uf 889 uf31 3.12345")),
         istream_iterator<string>(),
         [](const string& i) {
            char* it;
            double num = strtod(i.c_str(), &it);
            if (distance(i.c_str(), const_cast<const char*>(it)) == i.size()) cout << num << endl; });

However it is possible to accomplish this without the weight of an istringstream or a regex, by simply using strtok:

char buffer[] = " li 12.12 si 43,23 45 31 uf 889 uf31 3.12345";

for (auto i = strtok(buffer, " \f\n\r\t\v"); i != nullptr; i = strtok(nullptr, " \f\n\r\t\v")) {
    char* it;
    double num = strtod(i, &it);

    if (*it == '\0') cout << num << endl;
}

Note that for my delimiter argument I'm simply using the default isspace values.

Answer 4

Regexes are usually unreadable and hard to prove correct. Regexes matching only valid rational numbers need to be intricate and are easy to mess up. Therefore, I propose an alternative approach. Instead of regexes, tokenize your string with c++ and use std::strtod to test if input is a valid number. Here is example code:

std::vector<std::string> split(const std::string& str) {
    std::istringstream iss(str);
    return {
        std::istream_iterator<std::string>{iss},
        std::istream_iterator<std::string>{}
    };
}

bool isValidNumber(const std::string& str) {
    char* end;
    std::strtod(str.data(), &end);
    return *end == '\0';
}

// ...
auto tokens = split(" li 12.12 si 43,23 45 31 uf 889 uf31 3.12345");
std::vector<std::string> matches;
std::copy_if(tokens.begin(), tokens.end(), std::back_inserter(matches), isValidNumber);

Answer 5

Use negative lookahead and lookbehind to assert that there are no funny characters on either side of the number:

(?<![^\\s])(\\+|-)?[0-9]+(\\.[0-9]*)?(?![^\\s])

Unfortunately you're going to need Boost.Regex for the task as the builtin one doesn't support these constructs.

You're probably better off splitting the input into words and then using a simple regex on each word.

Answer 6

Two attempts:

#include <string>
#include <iostream>
#include <regex>
#include <sstream>


int main()
{
    using namespace std;

    string buffer(" li 12.12 si 43,23 45 31 uf 889 uf31 3.12345 .5");

    regex num_regex("(^|\\s)([\\+-]?([0-9]+\\.?[0-9]*|\\.?[0-9]+))(\\s|$)");
    smatch num_match;
    while (regex_search(buffer, num_match, num_regex))
    {
        if (num_match.size() >= 4) //3 groups = 4 matches
        {
            //We only need the second group
            auto token = num_match[2].str();
            cout << token << endl;
        }

        buffer = num_match.suffix().str();
    }
    return 0;
}

---

#include <string>
#include <iostream>
#include <regex>
#include <sstream>


int main()
{
    using namespace std;

    string buffer(" li 12.12 si 43,23 45 31 uf 889 uf31 3.12345 .5");

    istringstream iss(buffer);
    vector<string> tokens{ istream_iterator<string>{iss}, istream_iterator<string>{} };

    regex num_regex("^[\\+-]?([0-9]+\\.?[0-9]*|\\.?[0-9]+)$");
    for(auto token : tokens)
    {
        if (regex_search(token, num_regex))
        {
            //Valid entry
            cout << token << endl;
        }
    }

    return 0;
}

Answer 7

You could play with a trick to consume stuff you don't want. Something like this.

(?:\d+,|[a-z]+)\d+|(\d+[.\d]*)

Modfiy to everything that should be excluded in pipes pre capture and grab captures of first group.

See demo at regex101. No idea if (: non capture group is ok for c++. Remove, if not.