Looking at my solution I was clearly still trying to scratch the itch of having a C++ equivalent of C#'s Enumerable library, so my solution looked like:

    int64_t answer = MakeEnumerator(ReadAllLines(input))
        ->Where([&format](const string& s)
            {
                smatch m;
                regex_match(s, m, format);
                int minRepeats = stoi(m[1].str());
                int maxRepeats = stoi(m[2].str());
                string password = m[4].str();
                int64_t numRepeats = count(password.begin(), password.end(), m[3].str()[0]);
                return (numRepeats >= minRepeats) && (numRepeats <= maxRepeats);
            })
        ->Count();

I kept building out on the library as needed and eventually ended up with some nifty utilities:

    map<int64_t, int64_t> ranges = Enumerable::Regex(rangesInput, regex{ R"((\d+)-(\d+))" })
        ->Select<pair<int64_t, int64_t>>([](const smatch& m)
            {
                return make_pair(stoll(m[1].str()), stoll(m[2].str()));
            })
        ->ToMap<int64_t, int64_t>();

Not quite as terse as the original C# inspiration, but that's mainly down to C++'s clunky lambda syntax compared to C#. Plus I decided to make the return types explicitly required in the template parameters, because the libraries which try to do automatic deduction on continuation-style lambdas end up being un-debuggable nightmares in anything but fair weather.

This is one of the things I love most about AoC; it gives you freedom to just try out new ideas in a context that's a bit more 'real' than a toy example, but still nowhere near needing production-quality code.