Value not usable in constant expression alternative pattern - c++

Question

I am looking for an alternative c++ pattern to achieve this:
Read from an option from a file (let's say its either A or B).
In a cycle I want to repeat a call to a template function depending on the option, but I don't want to check the value each time, instead, I want the compiler to generate both possibilities and choose the one with template A if the option is set to A, and with template B if the option is set to B.
If i do this though:
Option option = readFromFile("AorB");
for(int i = 0; i < 100000; ++i)
{
performOperation<option>(); // Long but fast function I don't want to define twice
}
I get the following error:
error: the value of 'option' is not usable in a constant expression
How can I achieve the desired behaviour?

Answer 1

To make the code weirder and more meta ;) you could play a bit with variadic templates, lambdas and constexpr implicit cast:
#include <iostream>
template <char C>
struct Option {
constexpr operator char() {
return C;
}
};
template <char Opt>
void performOperation() {
std::cout << Opt << std::endl;
}
template <char... Options>
void runOption() {
char optionFromFile = 'a';
int dummy[] = {([](auto option, char chosen) {
if (chosen == option) {
for(int i = 0; i < 5; ++i) {
performOperation<option>();
}
}
}(Option<Options>{}, optionFromFile), 0)...};
static_cast<void>(dummy);
}
int main() {
runOption<'a', 'b'>();
}
[live demo]
Have fun!

Answer 2

As others have mentioned, you can't pass a variable to something that expects a compile time constant.
If you've got something that is either "A" or "B" and you're worried about checking for that each time then you could expand the loop/condition yourself:
Option option = readFromFile("AorB");
if(option.isA())
{
for(int i = 0; i < 100000; ++i)
{
performOperationA();
}
else
{
for(int i = 0; i < 100000; ++i)
{
performOperationB();
}
}

Answer 3

If you want the operation to select the behavior at runtime, then you may want to create a class to encapsulate the behavior that varies. Next create an instance of the class once based on the option value A or B. Then inside the loop, you pass the class instance to operation.
I've provided an example below that implements OptionA and OptionB in a class hierarchy. If you do it this way, then you don't even need a template at all. But you didn't provide much detail on how the behavior of your operation varies, so I didn't want to assume too much about what you have to work with. The template is only required if you have two unrelated classes that implement an identical interface.
#include <iostream>
#include <string>
class OptionType {
public: virtual int calculate( int x ) = 0;
};
class OptionA :public OptionType {
public: int calculate( int x ) { return x+99; }
};
class OptionB : public OptionType {
public: int calculate( int x ) { return x*100; }
};
template<class T>
void performOperation( T& option, int x ) {
// your performOperation is a long function
// this one is short but shows how the behavior can vary by option
std::cout << option.calculate( x ) << std::endl;
}
int main( int argc, char* argv[] )
{
// Option option = readFromFile("AorB");
// pass A or B from the command line
char option = (argc > 1) ? argv[1][0] : 'A'; // your code reads this from a file
OptionType* optionObject;
if( option == 'A' ) optionObject = new OptionA();
else optionObject = new OptionB();
for(int i = 0; i < 10; ++i)
{
performOperation( *optionObject, i );
}
}

Answer 4

you can't because the option is a variable, and a template is compile time. the performOperation needs to receive a constant value on the <>.
and since the operations occours on runtime - you need an if.
But you could use the branch prediction to do less work - if you sort the vector before passing to for / if call(value) else call_2(value), it would run much faster.

Answer 5

Template arguments must be known at compile time. At run time, it's too late to instantiate new instances of a template. You will need to force the generation of each instance that may be required at run time and implement some form of dispatching. The simplest approach is to have a dispatching function with a switch. For example :
enum class Option {
Opt1,
Opt2,
Opt3
};
template<Option opt>
void Operation() {}
void performOperation(const Option opt)
{
switch (opt)
{
case(Option::Opt1):
Operation<Option::Opt1>();
break;
case(Option::Opt2):
Operation<Option::Opt2>();
break;
case(Option::Opt3):
Operation<Option::Opt3>();
break;
default:
// Handle however you want
}
}
Another solution would use a map of std::function :
#include <map>
#include <functional>
enum class Option {
Opt1,
Opt2,
Opt3
};
template<Option opt>
void Operation() {}
const std::map<Option, std::function<void()>> func_map = {
{ Option::Opt1, []{Operation<Option::Opt1>(); }},
{ Option::Opt2, []{Operation<Option::Opt2>(); }},
{ Option::Opt3, []{Operation<Option::Opt3>(); }}
};
void performOperation(const Option opt)
{
func_map.at(opt)();
}

Answer 6

If I understood the question correctly.
You could try this way:
for(int i = 0; i < 100000; ++i)
{
#ifdef A
read("A");
#endif
#ifdef B
read("B");
#endif
}
and at compiler level you can choose:
g++ main.cpp -D A
or
g++ main.cpp -D B