Accessing a variable in C++ by "stitching" its name together - c++

Question

Let's say I have a variable:
int fish5 = 7;
Can I access fish5 by concatenation of the term "fish" and "5" somehow?
An ideal solution would look something like this:
printf("I am displaying the number seven: %i", fish + 5);

Answer 1

No, not exactly what you want. But in your example, you can use an Array (only works if you want to concatenate an variablename with an number):
int fish[6] = {0};
fish[5] = 7;
printf("I am displaying the number seven: %i", fish[5]);
See also here for an reference to Arrays in C++.
Another solution would be using a std::map instead, like pointed out by Thrustmaster in the comments.
Then you could write something like:
#include <map>
#include <string>
int main(int argc, char* argv[]){
std::map<std::string, int> map;
map.insert(std::make_pair("fish5", 7));
printf("I am displaying the number seven: %d", map[std::string("fish") + std::to_string(5)]);
return 0;
}
For more Information about std::map, see here.

Answer 2

It is impossible to transition the solution from the compile time to run time, because c++ is a compiled language, not interpreted one. The variable names "lose their meaning" after compilation. They are just a set of symbols with addresses. This means, that after compilation asking for something like fish5 makes no sense.
To achieve what you want, you need to bind the name to the object somehow programmatically for example by using a map, that stores names as keys, and object references as values. This is how python does it, and why in python you can actually access the object via its name from the code.
In case anyone would wonder why for example gdb or crash dumps are meaningful, it is for pretty much the same reason. The symbol names must be saved at the compilation time (either embedded in the executable or an external file), then an external tool can figure out what is the name of a variable under a certain address. But a compiled executable can work just fine with out this information.
Alternatively, you need to remember the reference itself in some more convenient way, that allows it to be computable. E.g. store it in an array and access as fish[5]; although in this example it can be evaluated at the compile time, you can use the same method at run-time using a variable in place of 5.
The distinction between compile-time and run-time is very important, because you can actually do what you want at the compile-time with preprocessor, but only because it is compile time.

Answer 3

You could use operating system specific things, like (on Posix e.g. Linux) dlsym(3) to access variables thru the symbol table inside the (unstripped) ELF executable at runtime.
So, preferably declare the variables you want to access by their name as extern "C" e.g.
extern "C" int fish17;
(otherwise, take into account compiler specific name mangling)
Declare also a program handle:
void *progdlh;
initialize it early in main
progdlh = dlopen(NULL, RTLD_NOW|RTLD_GLOBAL);
if (!progdlh) { fprintf(stderr, "dlopen failure %s\n", dlerror());
exit(EXIT_FAILURE); }
then, to retrieve your variable by a computed name you might try:
char nambuf[32];
snprintf (nambuf, sizeof(nambuf), "%s%d", "fish", 17);
int *pvar = dlsym(progdlh, nambuf);
if (!pvar) { fprintf(stderr, "dlsym %s failure %s\n", nambuf, dlerror());
exit(EXIT_FAILURE); }
printf ("variable %s is %d\n", nambuf, *pvar);
You'll probably should link your program with -rdynamic flag (and with the -ldl library)
My answer should work on Linux.

Answer 4

You can only do this at compile time, using preprocessor. Complete example:
#include <cstdio>
#define JOIN(a,b) a##b
int main(void) {
int fish5 = 5;
std::printf("I am displaying the number five: %i", JOIN(fish, 5));
return 0;
}
However, this is strictly compile time. If you try JOIN(fish, fish) you get error: ‘fishfish’ undeclared and if you try JOIN("fish", fish) you get error: pasting ""fish"" and "fish" does not give a valid preprocessing token.
In C++, variable names do not exist at runtime, so the operation can't be done at runtime, except though some deep debug info hackary to find variables by their name string (like a debugges does). If using strings is valid approach for you, then it's better to just have a map from string to variable address explicitly. Other answers show how to do this already, by using std::map.