Regular expression with all optional components How to avoid empty catches?

Let us start from the expression where each of the three magnitudes are optional

(?:\d+A)?(?:\d+B)?(?:\d+C)?

1. Anchor to the beginning of a value

To ensure that a value starts at the start of the text or at a comma, we add both options to the beginning.

(?:^|,) (?:\d+A)?(?:\d+B)?(?:\d+C)?
^^^^^^^

2. Avoid empty matches

As you showed in your last attempt, a positive assertion ( positive lookahead ) can be used to guarantee that there is some character before the comma, without consuming this character within the global match. We just need to verify that there is at least 1 digit ( \d).

(?:^|,) (?=\d) (?:\d+A)?(?:\d+B)?(?:\d+C)?
       ^^^^^^

3. Only match if it matches the entire pattern

Now, as you mentioned in your last comment, such a pattern could match the lookahead, but then match an empty string. For that, we will add that at the end it must match a comma or the end of the string. In this case, we use another assertion, so that it doesn't consume the next comma (and is available for a next match).

(?:^|,)(?=\d)(?:\d+A)?(?:\d+B)?(?:\d+C)? (?=,|$) 
                                        ^^^^^^^

Demo en regex101.com

4. Capture numbers and units separately

For practicality, we should use groups ( in parentheses ) to capture each of the values ​​separately.

(?:^|,)(?=\d)(?: ( \d+ )( A ) )?(?: ( \d+ )( B ) )?(?: ( \d+ )( C ) )?( ?=,|$)
                ^ ^^ ^ ^ ^^ ^ ^ ^^ ^

Demo en regex101.com

Code

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

int main() {
    string texto("48A30B50C,1A,1A1B1C,11111A,1C1B1A,1A1A1A,1C,1B,1443C,adfank,12322134445688,48A");
    regex patron(R"/((?:^|,)(?=\d)(?:(\d+)(A))?(?:(\d+)(B))?(?:(\d+)(C))?(?=,|$))/");

    //Iterar cada una de las coincidencias
    sregex_iterator next(texto.begin(), texto.end(), patron);
    sregex_iterator end;
    while (next != end) {
        smatch match = *next;

        //Coincidencia global (incluye la coma)
        cout << "Valor: " << match.str() << endl;

        //Iterar cada uno de los grupos (saltando de a 2)
        for( int grupo = 1; grupo < match.size(); grupo += 2 ) {
            string numero = match[grupo];
            string letra  = match[grupo+1];

            //Está el grupo o devolvió una cadena vacía por ser opcional?
            if (!letra.empty()) {
                cout << "\tNúmero: " << numero << endl
                     << "\tLetra:  " << letra  << endl;
            }
        }
        next++;
    }
}

Result:

Valor: 48A30B50C
    Número: 48
    Letra:  A
    Número: 30
    Letra:  B
    Número: 50
    Letra:  C
Valor: ,1A
    Número: 1
    Letra:  A
Valor: ,1A1B1C
    Número: 1
    Letra:  A
    Número: 1
    Letra:  B
    Número: 1
    Letra:  C
Valor: ,11111A
    Número: 11111
    Letra:  A
Valor: ,1C
    Número: 1
    Letra:  C
Valor: ,1B
    Número: 1
    Letra:  B
Valor: ,1443C
    Número: 1443
    Letra:  C
Valor: ,48A
    Número: 48
    Letra:  A

Demo en ideone.com

Let's take one of the three possible groups since the solution should be later extensible:

1x2y3z

What would be schematized:

\d+x\d+y\d+z

Now, each of these three groups is optional, although to avoid false positives we must assume that at least one will always be present. That is, the group must contain at least \d+x or \d+yor \d+z. This assumption has certain implications:

• If the group begins with \d+xit is possible that we find \d+yand\d+z
• If the group begins with \d+ywe may find \d+zbut we will never find\d+x
• If the group begins with \d+zwe will not be able to find neither \d+xnor\d+y

This taken to the regular expression would look like this:

(\d+x(?:\d+y)?(?:\d+z)?|\d+y(?:\d+z)?|\d+z)

This solution avoids retrieving empty strings since it always forces there to be at least one element.

As a result of a conversation in the chat with @Mariano, another option:

(\d+[xyz][^,]*)

This would only be indicated if you can guarantee that the received data is correct, since it would be eaten, for example 1x2345abracadabra, but of course it should be faster.

The above expression could be expanded to be slightly less forgiving:

((?:\d+[xyz]){1,3})