Is there a way to "pattern match" into a variable name?

I apologize in advance, this is going to be a goofy question but I don't know how to word a google search well enough to get a response for this.

Now I've been occasionally thinking about this, every time it would've made my code easier to write if it existed, let's say I have two vectors: vec0<int> and vec1<int>. (for the sake of the example).

Is there any way of doing something similar to the lines of the code below? Let's say we want to push the even numbers into vec0 and the odd numbers into vec1. It should look something like this

for(int i=0;i<=n;i++)
turnStringIntoVariable(f"vec{i%2}").push_back(i)

So a function would compute the name of the variable and fetch its address, then you can perform operations on the result.

Does anything like this exist in practice? This is out of sheer curiosity, really.

This is impossible to do in C++. There is no way to turn a string into a corresponding symbol (e.g. referring to a variable) at the C++ core language level either at run time or at compile time.

There is limited support for something similar at compile time in the preprocessor stage, but not with syntax like you want.

At run time like you are showing, it is fundamentally impossible, because C++ is statically-typed, so that the type of an expression cannot depend on run time values and because names of entities are pure compile-time concepts in C++. They don't exist at run time (and neither do variables themselves, really).

If you want to map strings to variables in C++, you need to provide the mapping one-to-one explicitly e.g. as a std::map<std::string, /*shared type of variables*/> or by writing a function that contains the mappings explicitly as part of the control flow.

But that is almost surely inefficient and e.g. in your example, you would really want to use something like a variadic template or a fold expression that applies pairs of i and variable to the expression repeatedly. The topic you should look at are templates (especially variadic ones) and common idioms like those using std::apply with tuples and std::index_sequence to generate compile-time numeric sequences corresponding to elements of template parameter packs so that they can be used together in fold expressions.

Or, as long as all your vecX have the same type, nothing as fancy as templates is even required. A simple array is enough:

std::array vecs = {std::ref(vec1), std::ref(vec2), std::ref(vec3)};
for(int i=0;i<vecs.size();i++)
    vecs[i].get().push_back(i);