if you know for sure that there are only going to be 2 places where you have a list of digits in your string and that is the only thing you are going to pull out then you should be able to simply use

\d+

In C++11, you should use std::stoi to convert a std::string to integer. (And no need to dereference it; in fact, *results[3] is a compile-error since it is not a pointer.)

int number = stoi(results[3]);
cout << number << endl;  // 15

Just use word boundaries. \b matches between a word character and a non-word character.

\b\d+\b

OR

\b[0-9]+\b

DEMO

Escape the backslash one more time if necessary like \\b\\d+\\b or \\b[0-9]+\\b

You can also use the built in find_first_of and find_first_not_of to find the first "numberstring" in any string.

    std::string first_numberstring(std::string const & str)
    {
      char const* digits = "0123456789";
      std::size_t const n = str.find_first_of(digits);
      if (n != std::string::npos)
      {
        std::size_t const m = str.find_first_not_of(digits, n);
        return str.substr(n, m != std::string::npos ? m-n : m);
      }
      return std::string();
    }

match[0] refers to the part of the text matched by the entire pattern. match[1] is the match corresponding to the first capture (parenthesized subpattern).

Note that &s[match[1].rm_so] gives you a pointer to the start of the capture, but if you print the string at that point, you will get the part of the string starting at the beginning of the capture. In this case, that doesn't really matter. Since you're using sscanf to extract the integer value of the captured text, the fact that the substring isn't terminated immediately doesn't matter; it's not going to be followed by a digit, and sscanf will stop at the first non-digit.

But in the general case, it's possible that it will not be so easy to identify the end of the matched capture, and you can use one of these techniques:

If you want to print the capture, you can use a computed string width format: (See Note 1.)

printf("%.*s\n", match[1].rm_eo - match[1].rm_so, &s[match[1].rm_so]);

If you have strndup, you can easily create a dynamically-allocated copy of the capture: (See Note 2.)

char* capture = strndup(&s[match[1].rm_so], match[1].rm_eo - match[1].rm_so);

As a quick-and-dirty hack, it is also possible to just insert a NUL terminator (assuming that the searched string is not immutable, which means that it cannot be a string literal). You'll probably want to save the old value of the following character so that you can restore the string to it's original state:

char* capture = &s[match[1].rm_so];
char* rest = &s[match[1].rm_eo];
char saved_char = *rest;
*rest = 0;
/* capture now points to a NUL-terminated string. */
/* ... */
/* restore s */
*rest = saved_char;

None of the above is really necessary in the context of the original question, since the sscanf as written will work perfectly if you change the start of the string to scan from match[0] to match[1].

Notes:

1. In the general case, you should test to make sure that a capture was actually found before trying to use its offset. The rm_so member will be -1 if the capture was not found during the regex search That doesn't necessarily mean that the search failed, because the capture could be part of an alternative not used in the match.

2. Don't forget to free the copy when you no longer need it. If you don't have strndup, it's pretty easy to implement. But watch out for the corner cases.

(?!\d+,\d+\.\d+,|\d+\.\d+,\d+.)^([+-]?(?:\d+|\d{1,3}(?:[.,]\d{3})*)(?:[.,]\d+|[eE][+-]?(?:\d+|\d{1,3}(?:[.,]\d{3})*))?)$

Perhaps something like this?

This will match all of the ones you stated, plus numbers written in the format 1e10 and 1e-9.

It will also not match numbers where there are inconsistencies in the comma dot format, i.e 10.234245,214,10.234,245.214 or 10,234.245,214

Also will allow for + or - at the beginning of these numbers

Check it out on Regex101

You can do it with strtol, like this:

char *str = "ab234cid*(s349*(20kd", *p = str;
while (*p) { // While there are more characters to process...
    if ( isdigit(*p) || ( (*p=='-'||*p=='+') && isdigit(*(p+1)) )) {
        // Found a number
        long val = strtol(p, &p, 10); // Read number
        printf("%ld\n", val); // and print it.
    } else {
        // Otherwise, move on to the next character.
        p++;
    }
}

Link to ideone.

Using sscanf and scansets the sub-strings can be extracted. The scanset %79[^:] will scan up to 79 characters that are not : and %79[0-9] will scan up to 79 characters that are digits. The %n specifier will capture the number of characters processed by the scan. This allow the sub-scans to start where the last scan left off.

#include <stdio.h>

int main ( void) {
    char a[80] = "";
    int c = 0;
    int result = 0;
    int each = 0;
    int span = 0;
    int offset = 0;
    char text[][80] = {
        "DATA:PHONENUMBER123456AGE7890"
        , "TEL:123"
        , "TEL1A:123456"
        , "TEL2B:123456"
    };

    while ( 1 == sscanf ( text[each], " %79[^:]:%n", a, &span)) {//scan up to : then scan :
        printf ( "\n%s\n", text[each]);//print full element of text array
        offset = span;
        printf ( "text before : = %s\n", a);
        do {
            if ( 1 == ( result = sscanf ( text[each] + offset, " %79[^0-9]%n", a, &span))) {// scan non-numbers
                offset += span;
                printf ( "\ttext = %s\n", a);
            }
            if ( 1 == ( result = sscanf ( text[each] + offset, " %79[0-9]%n", a, &span))) {//scan numbers
                offset += span;
                printf ( "\tnumber text = %s\n", a);
                if ( 1 == sscanf ( a, "%d", &c)) {//scan text number to int
                    printf ( "\tnumber value = %d\n", c);
                }
            }
        } while ( result != EOF);//loop until end of text[each]
        each++;//next element in text array
        if ( each >= 4) {
            break;
        }
    }
    return 0;
}

You need to call matcher.find() recursively until it returns false. Use a do/while block.

String str = '123-456/7890';
Pattern p = Pattern.compile('(\\d+)');
Matcher m = p.matcher( str );

if(m.find()) {
  do {
    system.debug( '-->>' + m.group() );
  } while(m.find());
}