Ignoring the first match in regex - c++

Question

I'm doing an exercise from C++ Primer
Rewrite your phone program so that it writes only the
second and subsequent phone numbers for people with more than one phone
number.
(The phone program simply recognises phone-numbers that have a certain format using a regular expression).
The chapter has been discussing using regex_replace and the format flags to alter the format of the phone numbers entered in. The question is asking to ignore the first phone number entered and only format/print the second and subsequent. My input might look something like:
dave: 050 000 0020, (402)2031032, [phone]
and it should output
402.203.1032 999.999.2222
This is my solution:
#include <iostream>
#include <string>
#include <regex>
using namespace std;
using namespace regex_constants;
int main(){
string pattern = "(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})";
regex r(pattern);
//string firstFormat = "";
string secondFormat = "$2.$5.$7 ";
for(string line; getline(cin, line);){
unsigned counter = 0;
for(sregex_iterator b(line.begin(), line.end(), r), e; b != e; ++b)
if(++counter > 1) cout << (*b).format(secondFormat);
cout << endl;
// Below: iterates through twice, maybe not ideal
// string noFirst = regex_replace(line, r, firstFormat, format_first_only); //removes the first phone number
// cout << regex_replace(noFirst, r, secondFormat, format_no_copy) << endl;
}
}
However I am unhappy with the use of a counter to make sure I'm not processing the first match. It feels like there must be a more natural utility (like the format_first_only flag that can be passed to format, except in reverse) that makes it possible to ignore the first match? But I am struggling to find one.
The commented out solution seems a bit better except it requires a second iteration through the input.

Answer 1

You could use the \G anchor.
"(?:(?!\\A)\\G|.*?\\d{3}\\D*\\d{3}\\D*\\d{4}).*?(\\d{3})\\D*(\\d{3})\\D*(\\d{4})"
And secondFormat = "$1.$2.$3 ";
Where there is no need for a counter.
Formatted:
(?:
(?! \A ) # Not beginning of string
\G # End of previous match
| # or,
.*? # Anything up to
\d{3} \D* \d{3} \D* \d{4} # First phone number
)
.*? # Anything up to
( \d{3} ) # (1), Next phone number
\D*
( \d{3} ) # (2)
\D*
( \d{4} ) # (3)
Input:
dave: 050 000 0020, (402)2031032, [phone]
Output:
** Grp 0 - ( pos 0 , len 32 )
dave: 050 000 0020, (402)2031032
** Grp 1 - ( pos 21 , len 3 )
402
** Grp 2 - ( pos 25 , len 3 )
203
** Grp 3 - ( pos 28 , len 4 )
1032
-------------------------------------
** Grp 0 - ( pos 32 , len 16 )
, [phone]
** Grp 1 - ( pos 35 , len 3 )
999
** Grp 2 - ( pos 40 , len 3 )
999
** Grp 3 - ( pos 44 , len 4 )
2221

Answer 2

How about change regex to be something like (?<=\P, *)(\P) (where \P is shorthand for a regex which matches a phone number). In other words, you are interested only in phone numbers which follow a previous phone number.
The only problem with this suggestion is that C++ doesn't appear to support positive look-behind.
(Note: you don't want all the captures in the first phone number.)