C++ How to conditionally initialize a template class object? - c++

Question

I have a template class
template <typename T>
class myClass
{
T variable;
....
};
I want to create an object of myClass , depending of some condition the object should either hold a string or int . how do I conditionally initialize like below :
if (condition1)
myClass<userDefinedType1> x;
else
myClass<userDefinedType2> x;
I don't think the code I wrote above is possible , but the problem is whether the type should be userDefinedType1 or userDefinedType2 is not known to me at compile time . How can I initialize the template class object when the type will only be known to me at run time based on user inputs ?

Answer 1

If the type of the problem isn't known until runtime, then your options are limited.
If the number of possible instantiations is small/simple and you are using c++17 or above, one option is to just use std::variant:
using MyClass = std::variant<std::monostate, myClass<userDefinedType1>,myClass<userDefinedType2>>;
auto v = MyClass{}; // create one without a value to start
if (condition) {
v = myClass<userDefinedType1>{};
} else {
v = myClass<userDefinedType2>{};
}
std::variant takes care of ensuring incorrect access does not occur (which prevents strict-aliasing violations), and it also will ensure that non-trivial destructors get invoked for the correctly instantiated types. This can then be used easily with visit assuming the functions that need to be called are homogeneously defined, since you can use a lambda with an auto parameter which will choose the correct type:
std::visit([](auto& cls){
cls.do_something();
}, v);
One other utility that can be used is std::any, for a similar purpose:
auto v = std::any{};
if (condition) {
v = myClass<userDefinedType1>{};
} else {
v = myClass<userDefinedType2>{};
}
The downside with std::any is that accessing the internal types is much more complicated and needs to be polled with std::any_cast. Still doable, but not so nice
Alternative, polymorphism is an option if your template might have some base-class that you can erase to. This may not work for every design, but in the case that it does you can simply use a std::unique_ptr to hold an instance to the base while you construct the class.
class myClassBase {
...
virtual auto common_api(...) -> void = 0;
...
};
template <typename T>
class myClass : public myClassBase {
...
auto common_api(...) -> void override { ... }
...
};
...
auto v = std::unique_ptr<Base>{};
if (condition) {
v = std::make_unique<myClass<userDefinedType1>>(...);
} else {
v = std::make_unique<myClass<userDefinedType2>>(...);
}
The last real option is to perform some form of manual type-erasure, where you create a wrapper class that erases the template argument. This solution is not generic and will be highly-specific to the class itself for how it can be erased. This may involve something as simple as a polymorphic wrapper that erases the type in the implementation, or it can be more complex such as bound function-pointers that do more work.

Answer 2

Ah, the crazy world of template metaprogramming (TMP). It's a lot easier now due to constexpr etc. but for programming the members of a class you still need to go old-school.
You have to generate your member by inheriting it from a base class.
That base class can be a template, including a fancy conditional TMP construct. You can see this in some of the standard library classes.
Hmm, you want the same data member (x), just having a different type. Well, that's easier: Make it of type T2. That can be generated using template stuff. Something like this:
using T2 = std::conditional_t<condition1, userDefinedType1, userDefinedType2>;
myClass<T2> x;
not known to me at compile time .
Well, that's another story. You can't change the generated code except at compile time.
Do you want a variable x that can hold either of two types?
That can use Object Oriented techniques of having a common polymorphic base class with different derived types.
Or, you can use a std::variant.
A (primitive) union as Ozger's answer shows is basically a low-level unchecked version of the same idea. In older versions of C++ such a union could not hold types that had constructors and destructors, but now they can, though you take on a lot of low-level effort. It's basically the language back-end to make writing variant simpler.

Answer 3

You can use a union.
union U {
myClass<userDefinedType1> a;
myClass<userDefinedType2> b;
};
U u;
if (condition1)
u.a = myClass<userDefinedType1>();
else
u.b = myClass<userDefinedType2>();
As stated in the comments, this compiles only if myClass has a trivial destructor, including the implicit destructor that will destruct T in myClass.

Answer 4

Unless you need to store x for future usage,
you can make the code which applies to x template too, and then you branch looks like:
template <typename T> void foo(T);
// ...
if (condition1) {
myClass<userDefinedType1> x;
foo(x);
} else {
myClass<userDefinedType2> x;
foo(x);
}
You can even move x in the function template, so code would be:
template <typename T> void bar(T)
{
myClass<T> x;
// ...
}
// ...
if (condition1) {
bar<userDefinedType1>();
} else {
bar<userDefinedType2>();
}
If you need to store x for future usage, you need either to use std::variant, polymorphism base class or type erasure.

Answer 5

Can't we just make class object dynamically. Something like this:
if (condition1)
myClass<userDefinedType1>* x = new myclass<userDefined1>;
else
myClass<userDefinedType2>* x = new myclass<userDefined2>;
Please let me know what's wrong with this approach